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="QEMU_TARGET_HELPER=${QEMU_TARGET_HELPER}"
 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                 riscv64)
 799                         QEMU_CPU="${QEMU_CPU:-sifive-u54}"
 800
 801                         env="${env} QEMU_CPU=${QEMU_CPU}"
 802                         ;;
 803         esac
 804
 805         # Enable QEMU strace
 806         #env="${env} QEMU_STRACE=1"
 807
 808         echo "${env}"
 809 }
 810
 811 qemu_is_required() {
 812         local build_arch="${1}"
 813
 814         if [ -z "${build_arch}" ]; then
 815                 build_arch="${BUILD_ARCH}"
 816         fi
 817
 818         case "${HOST_ARCH},${build_arch}" in
 819                 x86_64,arm*|x86_64,aarch64|x86_64,riscv64|i?86,arm*|i?86,aarch64|i?86,x86_64)
 820                         return 0
 821                         ;;
 822                 *)
 823                         return 1
 824                         ;;
 825         esac
 826 }
 827
 828 qemu_install_helper() {
 829         # Do nothing, if qemu is not required
 830         if ! qemu_is_required; then
 831                 return 0
 832         fi
 833
 834         if [ ! -e /proc/sys/fs/binfmt_misc/status ]; then
 835                 exiterror "binfmt_misc not mounted. QEMU_TARGET_HELPER not useable."
 836         fi
 837
 838         if [ ! $(cat /proc/sys/fs/binfmt_misc/status) = 'enabled' ]; then
 839                 exiterror "binfmt_misc not enabled. QEMU_TARGET_HELPER not useable."
 840         fi
 841
 842
 843         if [ -z "${QEMU_TARGET_HELPER}" ]; then
 844                 exiterror "QEMU_TARGET_HELPER not set"
 845         fi
 846
 847         # Check if the helper is already installed.
 848         if [ -x "${LFS}${QEMU_TARGET_HELPER}" ]; then
 849                 return 0
 850         fi
 851
 852         # Try to find a suitable binary that we can install
 853         # to the build environment.
 854         local file
 855         for file in "${QEMU_TARGET_HELPER}" "${QEMU_TARGET_HELPER}-static"; do
 856                 # file must exist and be executable.
 857                 [ -x "${file}" ] || continue
 858
 859                 # Must be static.
 860                 file_is_static "${file}" || continue
 861
 862                 local dirname="${LFS}$(dirname "${file}")"
 863                 mkdir -p "${dirname}"
 864
 865                 install -m 755 "${file}" "${LFS}${QEMU_TARGET_HELPER}"
 866                 return 0
 867         done
 868
 869         exiterror "Could not find a statically-linked QEMU emulator: ${QEMU_TARGET_HELPER}"
 870 }
 871
 872 qemu_find_build_helper_name() {
 873         local build_arch="${1}"
 874
 875         local magic
 876         case "${build_arch}" in
 877                 aarch64)
 878                         magic="7f454c460201010000000000000000000200b700"
 879                         ;;
 880                 arm*)
 881                         magic="7f454c4601010100000000000000000002002800"
 882                         ;;
 883                 riscv64)
 884                         magic="7f454c460201010000000000000000000200f300"
 885                         ;;
 886                 x86_64)
 887                         magic="7f454c4602010100000000000000000002003e00"
 888                         ;;
 889         esac
 890
 891         [ -z "${magic}" ] && return 1
 892
 893         local file
 894         for file in /proc/sys/fs/binfmt_misc/*; do
 895                 # skip write only register entry
 896                 [ $(basename "${file}") = "register" ] && continue
 897                 # Search for the file with the correct magic value.
 898                 grep -qE "^magic ${magic}$" "${file}" || continue
 899
 900                 local interpreter="$(grep "^interpreter" "${file}" | awk '{ print $2 }')"
 901
 902                 [ -n "${interpreter}" ] || continue
 903                 [ "${interpreter:0:1}" = "/" ] || continue
 904                 [ -x "${interpreter}" ] || continue
 905
 906                 echo "${interpreter}"
 907                 return 0
 908         done
 909
 910         return 1
 911 }
 912
 913 file_is_static() {
 914         local file="${1}"
 915
 916         file -L "${file}" 2>/dev/null | grep -q "statically linked"
 917 }
 918
 919 update_language_list() {
 920         local path="${1}"
 921
 922         local lang
 923         for lang in ${path}/*.po; do
 924                 lang="$(basename "${lang}")"
 925                 echo "${lang%*.po}"
 926         done | sort -u > "${path}/LINGUAS"
 927 }
 928
 929 contributors() {
 930         local commits name
 931
 932         git shortlog --summary --numbered | while read -r commits name; do
 933                 echo "${name}"
 934         done | grep -vE -e "^(alpha197|morlix|root|ummeegge)$" -e "via Development$" -e "@" -e "#$"
 935 }
 936
 937 update_contributors() {
 938         echo -n "Updating list of contributors"
 939
 940         local contributors="$(contributors | paste -sd , - | sed -e "s/,/&\\\\n/g")"
 941
 942         # Edit contributors into credits.cgi
 943         local tmp="$(mktemp)"
 944
 945         awk "/<!-- CONTRIBUTORS -->/{ p=1; print; printf \"${contributors}\n\"}/<!-- END -->/{ p=0 } !p" \
 946                 < "${BASEDIR}/html/cgi-bin/credits.cgi" > "${tmp}"
 947
 948         # Copy back modified content
 949         cat "${tmp}" > "${BASEDIR}/html/cgi-bin/credits.cgi"
 950         unlink "${tmp}"
 951
 952         print_status DONE
 953         return 0
 954 }
 955
 956 # Default settings
 957 CCACHE_CACHE_SIZE="4G"
 958 ENABLE_RAMDISK="auto"
 959
 960 # Load configuration file
 961 if [ -f .config ]; then
 962         . .config
 963 fi
 964
 965 # TARGET_ARCH is BUILD_ARCH now
 966 if [ -n "${TARGET_ARCH}" ]; then
 967         BUILD_ARCH="${TARGET_ARCH}"
 968         unset TARGET_ARCH
 969 fi
 970
 971 # Get some information about the host system
 972 SYSTEM_PROCESSORS="$(system_processors)"
 973 SYSTEM_MEMORY="$(system_memory)"
 974
 975 if [ -n "${BUILD_ARCH}" ]; then
 976         configure_build "${BUILD_ARCH}"
 977 else
 978         configure_build "default"
 979 fi
 980
 981 # Automatically enable/disable ramdisk usage
 982 if [ "${ENABLE_RAMDISK}" = "auto" ]; then
 983         # Enable only when the host system has 4GB of RAM or more
 984         if [ ${SYSTEM_MEMORY} -ge 3900 ]; then
 985                 ENABLE_RAMDISK="on"
 986         fi
 987 fi
 988
 989 buildtoolchain() {
 990         local error=false
 991         case "${BUILD_ARCH}:${HOST_ARCH}" in
 992                 # x86_64
 993                 x86_64:x86_64)
 994                          # This is working.
 995                          ;;
 996
 997                 # ARM
 998                 arvm7hl:armv7hl|armv7hl:armv7l)
 999                         # These are working.
1000                         ;;
1001
1002                 armv6l:armv6l|armv6l:armv7l|armv6l:aarch64)
1003                         # These are working.
1004                         ;;
1005                 armv6l:*)
1006                         error=true
1007                         ;;
1008         esac
1009
1010         ${error} && \
1011                 exiterror "Cannot build ${BUILD_ARCH} toolchain on $(uname -m). Please use the download if any."
1012
1013         local gcc=$(type -p gcc)
1014         if [ -z "${gcc}" ]; then
1015                 exiterror "Could not find GCC. You will need a working build enviroment in order to build the toolchain."
1016         fi
1017
1018         # Check ${TOOLS_DIR} symlink
1019         if [ -h "${TOOLS_DIR}" ]; then
1020                 rm -f "${TOOLS_DIR}"
1021         fi
1022
1023         if [ ! -e "${TOOLS_DIR}" ]; then
1024                 ln -s "${BASEDIR}/build${TOOLS_DIR}" "${TOOLS_DIR}"
1025         fi
1026
1027         if [ ! -h "${TOOLS_DIR}" ]; then
1028                 exiterror "Could not create ${TOOLS_DIR} symbolic link"
1029         fi
1030
1031         LOGFILE="$BASEDIR/log/_build.toolchain.log"
1032         export LOGFILE
1033
1034         lfsmake1 stage1
1035         lfsmake1 binutils                       PASS=1
1036         lfsmake1 gcc                    PASS=1
1037         lfsmake1 linux                  KCFG="-headers"
1038         lfsmake1 glibc
1039         lfsmake1 libxcrypt
1040         lfsmake1 gcc                    PASS=L
1041         lfsmake1 zlib
1042         lfsmake1 binutils                       PASS=2
1043         lfsmake1 gcc                    PASS=2
1044         lfsmake1 zstd
1045         lfsmake1 ccache
1046         lfsmake1 tcl
1047         lfsmake1 expect
1048         lfsmake1 dejagnu
1049         lfsmake1 pkg-config
1050         lfsmake1 ncurses
1051         lfsmake1 bash
1052         lfsmake1 bzip2
1053         lfsmake1 automake
1054         lfsmake1 coreutils
1055         lfsmake1 diffutils
1056         lfsmake1 findutils
1057         lfsmake1 gawk
1058         lfsmake1 gettext
1059         lfsmake1 grep
1060         lfsmake1 gzip
1061         lfsmake1 m4
1062         lfsmake1 make
1063         lfsmake1 patch
1064         lfsmake1 perl
1065         lfsmake1 python3
1066         lfsmake1 sed
1067         lfsmake1 tar
1068         lfsmake1 texinfo
1069         lfsmake1 xz
1070         lfsmake1 bison
1071         lfsmake1 flex
1072         lfsmake1 fake-environ
1073         CUSTOM_PATH="${PATH}" lfsmake1 strip
1074         lfsmake1 cleanup-toolchain
1075 }
1076
1077 buildbase() {
1078         LOGFILE="$BASEDIR/log/_build.base.log"
1079         export LOGFILE
1080         lfsmake2 stage2
1081         lfsmake2 linux                  KCFG="-headers"
1082         lfsmake2 man-pages
1083         lfsmake2 glibc
1084         lfsmake2 tzdata
1085         lfsmake2 cleanup-toolchain
1086         lfsmake2 zlib
1087         lfsmake2 zstd
1088         lfsmake2 autoconf
1089         lfsmake2 automake
1090         lfsmake2 libtool
1091         lfsmake2 binutils
1092         lfsmake2 gmp
1093         lfsmake2 mpfr
1094         lfsmake2 libmpc
1095         lfsmake2 libxcrypt
1096         lfsmake2 file
1097         lfsmake2 gcc
1098         lfsmake2 sed
1099         lfsmake2 berkeley
1100         lfsmake2 coreutils
1101         lfsmake2 iana-etc
1102         lfsmake2 m4
1103         lfsmake2 bison
1104         lfsmake2 ncurses
1105         lfsmake2 perl
1106         lfsmake2 readline
1107         lfsmake2 bzip2
1108         lfsmake2 xz
1109         lfsmake2 lzip
1110         lfsmake2 pcre
1111         lfsmake2 pcre2
1112         lfsmake2 gettext
1113         lfsmake2 attr
1114         lfsmake2 acl
1115         lfsmake2 bash
1116         lfsmake2 diffutils
1117         lfsmake2 ed
1118         lfsmake2 findutils
1119         lfsmake2 flex
1120         lfsmake2 gawk
1121         lfsmake2 go
1122         lfsmake2 grep
1123         lfsmake2 groff
1124         lfsmake2 gperf
1125         lfsmake2 gzip
1126         lfsmake2 hostname
1127         lfsmake2 whois
1128         lfsmake2 kbd
1129         lfsmake2 less
1130         lfsmake2 pkg-config
1131         lfsmake2 procps
1132         lfsmake2 make
1133         lfsmake2 man
1134         lfsmake2 net-tools
1135         lfsmake2 patch
1136         lfsmake2 psmisc
1137         lfsmake2 shadow
1138         lfsmake2 sysklogd
1139         lfsmake2 sysvinit
1140         lfsmake2 tar
1141         lfsmake2 texinfo
1142         lfsmake2 util-linux
1143         lfsmake2 vim
1144         lfsmake2 e2fsprogs
1145         lfsmake2 jq
1146 }
1147
1148 buildipfire() {
1149   LOGFILE="$BASEDIR/log/_build.ipfire.log"
1150   export LOGFILE
1151   lfsmake2 configroot
1152   lfsmake2 initscripts
1153   lfsmake2 backup
1154   lfsmake2 rust
1155   lfsmake2 openssl
1156   lfsmake2 kmod
1157   lfsmake2 udev
1158   lfsmake2 popt
1159   lfsmake2 libedit
1160   lfsmake2 libusb
1161   lfsmake2 libusb-compat
1162   lfsmake2 libpcap
1163   lfsmake2 ppp
1164   lfsmake2 pptp
1165   lfsmake2 unzip
1166   lfsmake2 which
1167   lfsmake2 linux-firmware
1168   lfsmake2 dvb-firmwares
1169   lfsmake2 xr819-firmware
1170   lfsmake2 zd1211-firmware
1171   lfsmake2 rpi-firmware
1172   lfsmake2 intel-microcode
1173   lfsmake2 pcengines-apu-firmware
1174   lfsmake2 bc
1175   lfsmake2 u-boot MKIMAGE=1
1176   lfsmake2 cpio
1177   lfsmake2 mdadm
1178   lfsmake2 dracut
1179   lfsmake2 libaio
1180   lfsmake2 lvm2
1181   lfsmake2 multipath-tools
1182   lfsmake2 freetype
1183   lfsmake2 libmnl
1184   lfsmake2 libnfnetlink
1185   lfsmake2 libnetfilter_queue
1186   lfsmake2 libnetfilter_conntrack
1187   lfsmake2 libnetfilter_cthelper
1188   lfsmake2 libnetfilter_cttimeout
1189   lfsmake2 iptables
1190   lfsmake2 iproute2
1191   lfsmake2 screen
1192   lfsmake2 elfutils
1193
1194   # Kernelbuild ... current we have no platform that need
1195   # multi kernel builds so KCFG is empty
1196   lfsmake2 linux                KCFG=""
1197   lfsmake2 rtl8189es            KCFG=""
1198   lfsmake2 rtl8189fs            KCFG=""
1199   lfsmake2 rtl8812au            KCFG=""
1200   lfsmake2 rtl8822bu            KCFG=""
1201   lfsmake2 xradio               KCFG=""
1202   lfsmake2 linux-initrd         KCFG=""
1203
1204   lfsmake2 libgpg-error
1205   lfsmake2 libgcrypt
1206   lfsmake2 libassuan
1207   lfsmake2 nettle
1208   lfsmake2 json-c
1209   lfsmake2 libconfig
1210   lfsmake2 libevent
1211   lfsmake2 libevent2
1212   lfsmake2 expat
1213   lfsmake2 apr
1214   lfsmake2 aprutil
1215   lfsmake2 unbound
1216   lfsmake2 gnutls
1217   lfsmake2 libuv
1218   lfsmake2 bind
1219   lfsmake2 dhcp
1220   lfsmake2 dhcpcd
1221   lfsmake2 boost
1222   lfsmake2 linux-atm
1223   lfsmake2 gdbm
1224   lfsmake2 pam
1225   lfsmake2 c-ares
1226   lfsmake2 curl
1227   lfsmake2 tcl
1228   lfsmake2 sqlite
1229   lfsmake2 libffi
1230   lfsmake2 python3
1231   lfsmake2 rust
1232   lfsmake2 rust-dissimilar
1233   lfsmake2 rust-cfg-if
1234   lfsmake2 rust-libc
1235   lfsmake2 rust-getrandom
1236   lfsmake2 rust-typenum
1237   lfsmake2 rust-version-check
1238   lfsmake2 rust-generic-array
1239   lfsmake2 rust-cipher
1240   lfsmake2 rust-hex
1241   lfsmake2 rust-unicode-xid
1242   lfsmake2 rust-proc-macro2
1243   lfsmake2 rust-quote
1244   lfsmake2 rust-syn
1245   lfsmake2 rust-home
1246   lfsmake2 rust-lazy-static
1247   lfsmake2 rust-memchr
1248   lfsmake2 rust-aho-corasick
1249   lfsmake2 rust-regex-syntax
1250   lfsmake2 rust-regex
1251   lfsmake2 rust-ucd-trie
1252   lfsmake2 rust-pest
1253   lfsmake2 rust-semver-parser
1254   lfsmake2 rust-semver
1255   lfsmake2 rust-same-file
1256   lfsmake2 rust-walkdir
1257   lfsmake2 rust-dirs
1258   lfsmake2 rust-toolchain_find
1259   lfsmake2 rust-serde
1260   lfsmake2 rust-itoa
1261   lfsmake2 rust-ryu
1262   lfsmake2 rust-serde_json
1263   lfsmake2 rust-synstructure
1264   lfsmake2 rust-block-buffer
1265   lfsmake2 rust-crypto-common
1266   lfsmake2 rust-digest
1267   lfsmake2 rust-ppv-lite86
1268   lfsmake2 rust-rand_core
1269   lfsmake2 rust-rand_core-0.4.2
1270   lfsmake2 rust-rand_core-0.3.1
1271   lfsmake2 rust-rand_chacha
1272   lfsmake2 rust-rand_hc
1273   lfsmake2 rust-rand
1274   lfsmake2 rust-rdrand
1275   lfsmake2 rust-rand-0.4
1276   lfsmake2 rust-log
1277   lfsmake2 rust-num_cpus
1278   lfsmake2 rust-crossbeam-utils
1279   lfsmake2 rust-autocfg
1280   lfsmake2 rust-memoffset
1281   lfsmake2 rust-scopeguard
1282   lfsmake2 rust-crossbeam-epoch
1283   lfsmake2 rust-crossbeam-deque
1284   lfsmake2 rust-either
1285   lfsmake2 rust-crossbeam-channel
1286   lfsmake2 rust-rayon-core
1287   lfsmake2 rust-rayon
1288   lfsmake2 rust-remove_dir_all
1289   lfsmake2 rust-tempdir
1290   lfsmake2 rust-glob
1291   lfsmake2 rust-once_cell
1292   lfsmake2 rust-termcolor
1293   lfsmake2 rust-toml
1294   lfsmake2 rust-serde_derive
1295   lfsmake2 rust-trybuild
1296   lfsmake2 rust-unindent
1297   lfsmake2 rust-proc-macro-hack
1298   lfsmake2 rust-indoc-impl
1299   lfsmake2 rust-indoc
1300   lfsmake2 rust-instant
1301   lfsmake2 rust-lock_api
1302   lfsmake2 rust-smallvec
1303   lfsmake2 rust-parking_lot_core
1304   lfsmake2 rust-parking_lot
1305   lfsmake2 rust-paste-impl
1306   lfsmake2 rust-paste
1307   lfsmake2 rust-ctor
1308   lfsmake2 rust-ghost
1309   lfsmake2 rust-inventory-impl
1310   lfsmake2 rust-inventory
1311   lfsmake2 rust-pyo3-build-config
1312   lfsmake2 rust-pyo3-macros-backend
1313   lfsmake2 rust-pyo3-macros
1314   lfsmake2 rust-pyo3
1315   lfsmake2 gdb
1316   lfsmake2 grub
1317   lfsmake2 efivar
1318   lfsmake2 efibootmgr
1319   lfsmake2 libtasn1
1320   lfsmake2 p11-kit
1321   lfsmake2 ca-certificates
1322   lfsmake2 fireinfo
1323   lfsmake2 libnet
1324   lfsmake2 libnl
1325   lfsmake2 libnl-3
1326   lfsmake2 libidn
1327   lfsmake2 nasm
1328   lfsmake2 libarchive
1329   lfsmake2 cmake
1330   lfsmake2 ninja
1331   lfsmake2 meson
1332   lfsmake2 libjpeg
1333   lfsmake2 openjpeg
1334   lfsmake2 libexif
1335   lfsmake2 libpng
1336   lfsmake2 libtiff
1337   lfsmake2 libart
1338   lfsmake2 gd
1339   lfsmake2 slang
1340   lfsmake2 newt
1341   lfsmake2 libsmooth
1342   lfsmake2 libcap
1343   lfsmake2 libcap-ng
1344   lfsmake2 pciutils
1345   lfsmake2 usbutils
1346   lfsmake2 libxml2
1347   lfsmake2 libxslt
1348   lfsmake2 perl-BerkeleyDB
1349   lfsmake2 cyrus-sasl
1350   lfsmake2 openldap
1351   lfsmake2 apache2
1352   lfsmake2 web-user-interface
1353   lfsmake2 flag-icons
1354   lfsmake2 jquery
1355   lfsmake2 bootstrap
1356   lfsmake2 arping
1357   lfsmake2 beep
1358   lfsmake2 libssh
1359   lfsmake2 libinih
1360   lfsmake2 cdrkit
1361   lfsmake2 dosfstools
1362   lfsmake2 exfatprogs
1363   lfsmake2 reiserfsprogs
1364   lfsmake2 liburcu
1365   lfsmake2 xfsprogs
1366   lfsmake2 sysfsutils
1367   lfsmake2 fuse
1368   lfsmake2 ntfs-3g
1369   lfsmake2 ethtool
1370   lfsmake2 fcron
1371   lfsmake2 perl-ExtUtils-PkgConfig
1372   lfsmake2 perl-GD
1373   lfsmake2 perl-GD-Graph
1374   lfsmake2 perl-GD-TextUtil
1375   lfsmake2 perl-Device-SerialPort
1376   lfsmake2 perl-Device-Modem
1377   lfsmake2 perl-Apache-Htpasswd
1378   lfsmake2 perl-Parse-Yapp
1379   lfsmake2 perl-Data-UUID
1380   lfsmake2 perl-Try-Tiny
1381   lfsmake2 perl-HTTP-Message
1382   lfsmake2 perl-HTTP-Date
1383   lfsmake2 gnupg
1384   lfsmake2 hdparm
1385   lfsmake2 sdparm
1386   lfsmake2 whatmask
1387   lfsmake2 libtirpc
1388   lfsmake2 conntrack-tools
1389   lfsmake2 iputils
1390   lfsmake2 l7-protocols
1391   lfsmake2 hwdata
1392   lfsmake2 logrotate
1393   lfsmake2 logwatch
1394   lfsmake2 misc-progs
1395   lfsmake2 nano
1396   lfsmake2 perl-URI
1397   lfsmake2 perl-CGI
1398   lfsmake2 perl-Switch
1399   lfsmake2 perl-HTML-Tagset
1400   lfsmake2 perl-HTML-Parser
1401   lfsmake2 perl-HTML-Template
1402   lfsmake2 perl-Compress-Zlib
1403   lfsmake2 perl-Digest
1404   lfsmake2 perl-Digest-SHA1
1405   lfsmake2 perl-Digest-HMAC
1406   lfsmake2 perl-libwww
1407         lfsmake2 perl-LWP-Protocol-https
1408   lfsmake2 perl-Net-HTTP
1409   lfsmake2 perl-Net-DNS
1410   lfsmake2 perl-Net-IPv4Addr
1411   lfsmake2 perl-Net_SSLeay
1412   lfsmake2 perl-IO-Stringy
1413   lfsmake2 perl-IO-Socket-SSL
1414   lfsmake2 perl-Unix-Syslog
1415   lfsmake2 perl-Mail-Tools
1416   lfsmake2 perl-MIME-Tools
1417   lfsmake2 perl-Net-Server
1418   lfsmake2 perl-Canary-Stability
1419   lfsmake2 perl-Convert-TNEF
1420   lfsmake2 perl-Convert-UUlib
1421   lfsmake2 perl-Archive-Tar
1422   lfsmake2 perl-Archive-Zip
1423   lfsmake2 perl-Text-Tabs+Wrap
1424   lfsmake2 perl-XML-Parser
1425   lfsmake2 perl-Crypt-PasswdMD5
1426   lfsmake2 perl-Net-Telnet
1427   lfsmake2 python3-setuptools
1428   lfsmake2 python3-inotify
1429   lfsmake2 python3-docutils
1430   lfsmake2 python3-daemon
1431   lfsmake2 glib
1432   lfsmake2 ntp
1433   lfsmake2 openssh
1434   lfsmake2 fontconfig
1435   lfsmake2 dejavu-fonts-ttf
1436   lfsmake2 ubuntu-font-family
1437   lfsmake2 freefont
1438   lfsmake2 pixman
1439   lfsmake2 cairo
1440   lfsmake2 harfbuzz
1441   lfsmake2 fribidi
1442   lfsmake2 pango
1443   lfsmake2 rrdtool
1444   lfsmake2 setup
1445   lfsmake2 libdnet
1446   lfsmake2 jansson
1447   lfsmake2 yaml
1448   lfsmake2 libhtp
1449   lfsmake2 colm
1450   lfsmake2 ragel
1451   lfsmake2 hyperscan
1452   lfsmake2 suricata
1453   lfsmake2 oinkmaster
1454   lfsmake2 ids-ruleset-sources
1455   lfsmake2 squid
1456   lfsmake2 squidguard
1457   lfsmake2 calamaris
1458   lfsmake2 tcpdump
1459   lfsmake2 traceroute
1460   lfsmake2 vlan
1461   lfsmake2 wireless
1462   lfsmake2 pakfire
1463   lfsmake2 spandsp
1464   lfsmake2 lz4
1465   lfsmake2 lzo
1466   lfsmake2 openvpn
1467   lfsmake2 mpage
1468   lfsmake2 dbus
1469   lfsmake2 intltool
1470   lfsmake2 libdaemon
1471   lfsmake2 avahi
1472   lfsmake2 cups
1473   lfsmake2 lcms2
1474   lfsmake2 ghostscript
1475   lfsmake2 qpdf
1476   lfsmake2 poppler
1477   lfsmake2 poppler-data
1478   lfsmake2 cups-filters
1479   lfsmake2 epson-inkjet-printer-escpr
1480   lfsmake2 foomatic
1481   lfsmake2 hplip
1482   lfsmake2 cifs-utils
1483   lfsmake2 krb5
1484   lfsmake2 rpcsvc-proto
1485   lfsmake2 samba
1486   lfsmake2 netatalk
1487   lfsmake2 sudo
1488   lfsmake2 mc
1489   lfsmake2 wget
1490   lfsmake2 bridge-utils
1491   lfsmake2 smartmontools
1492   lfsmake2 htop
1493   lfsmake2 chkconfig
1494   lfsmake2 postfix
1495   lfsmake2 fetchmail
1496   lfsmake2 clamav
1497   lfsmake2 perl-NetAddr-IP
1498   lfsmake2 dma
1499   lfsmake2 alsa
1500   lfsmake2 mpfire
1501   lfsmake2 guardian
1502   lfsmake2 libid3tag
1503   lfsmake2 libmad
1504   lfsmake2 libogg
1505   lfsmake2 libvorbis
1506   lfsmake2 flac
1507   lfsmake2 lame
1508   lfsmake2 sox
1509   lfsmake2 soxr
1510   lfsmake2 libshout
1511   lfsmake2 xvid
1512   lfsmake2 libmpeg2
1513   lfsmake2 gnump3d
1514   lfsmake2 rsync
1515   lfsmake2 rpcbind
1516   lfsmake2 keyutils
1517   lfsmake2 nfs
1518   lfsmake2 gnu-netcat
1519   lfsmake2 ncat
1520   lfsmake2 nmap
1521   lfsmake2 etherwake
1522   lfsmake2 bwm-ng
1523   lfsmake2 sysstat
1524   lfsmake2 strongswan
1525   lfsmake2 rng-tools
1526   lfsmake2 lsof
1527   lfsmake2 br2684ctl
1528   lfsmake2 pcmciautils
1529   lfsmake2 lm_sensors
1530   lfsmake2 libstatgrab
1531   lfsmake2 liboping
1532   lfsmake2 collectd
1533   lfsmake2 elinks
1534   lfsmake2 igmpproxy
1535   lfsmake2 opus
1536   lfsmake2 python3-pyparsing
1537   lfsmake2 spice-protocol
1538   lfsmake2 spice
1539   lfsmake2 sdl2
1540   lfsmake2 libusbredir
1541   lfsmake2 libseccomp
1542   lfsmake2 qemu
1543   lfsmake2 netpbm
1544   lfsmake2 netsnmpd
1545   lfsmake2 nagios_nrpe
1546   lfsmake2 nagios-plugins
1547   lfsmake2 icinga
1548   lfsmake2 observium-agent
1549   lfsmake2 ebtables
1550   lfsmake2 faad2
1551   lfsmake2 alac
1552   lfsmake2 ffmpeg
1553   lfsmake2 vdr
1554   lfsmake2 vdr_streamdev
1555   lfsmake2 vdr_epgsearch
1556   lfsmake2 vdr_dvbapi
1557   lfsmake2 vdr_eepg
1558   lfsmake2 w_scan
1559   lfsmake2 mpd
1560   lfsmake2 libmpdclient
1561   lfsmake2 mpc
1562   lfsmake2 perl-Net-CIDR-Lite
1563   lfsmake2 perl-Net-SMTP-SSL
1564   lfsmake2 perl-MIME-Base64
1565   lfsmake2 perl-Authen-SASL
1566   lfsmake2 perl-MIME-Lite
1567   lfsmake2 perl-Email-Date-Format
1568   lfsmake2 git
1569   lfsmake2 squidclamav
1570   lfsmake2 vnstat
1571   lfsmake2 iw
1572   lfsmake2 wpa_supplicant
1573   lfsmake2 hostapd
1574   lfsmake2 syslinux
1575   lfsmake2 tftpd
1576   lfsmake2 cpufrequtils
1577   lfsmake2 gutenprint
1578   lfsmake2 apcupsd
1579   lfsmake2 fireperf
1580   lfsmake2 iperf
1581   lfsmake2 iperf3
1582   lfsmake2 7zip
1583   lfsmake2 lynis
1584   lfsmake2 sshfs
1585   lfsmake2 taglib
1586   lfsmake2 sslh
1587   lfsmake2 perl-gettext
1588   lfsmake2 perl-Sort-Naturally
1589   lfsmake2 vdradmin
1590   lfsmake2 perl-DBI
1591   lfsmake2 perl-DBD-SQLite
1592   lfsmake2 perl-File-ReadBackwards
1593   lfsmake2 openvmtools
1594   lfsmake2 joe
1595   lfsmake2 monit
1596   lfsmake2 nut
1597   lfsmake2 watchdog
1598   lfsmake2 libpri
1599   lfsmake2 usb_modeswitch
1600   lfsmake2 usb_modeswitch_data
1601   lfsmake2 zerofree
1602   lfsmake2 minicom
1603   lfsmake2 ddrescue
1604   lfsmake2 powertop
1605   lfsmake2 parted
1606   lfsmake2 swig
1607   lfsmake2 dtc
1608   lfsmake2 u-boot
1609   lfsmake2 u-boot-friendlyarm
1610   lfsmake2 wireless-regdb
1611   lfsmake2 libsolv
1612   lfsmake2 ddns
1613   lfsmake2 python3-pycparser
1614   lfsmake2 python3-charset-normalizer
1615   lfsmake2 python3-certifi
1616   lfsmake2 python3-idna
1617   lfsmake2 python3-requests
1618   lfsmake2 python3-toml
1619   lfsmake2 python3-pyproject2setuppy
1620   lfsmake2 python3-tomli
1621   lfsmake2 python3-pep517
1622   lfsmake2 python3-build
1623   lfsmake2 python3-install
1624   lfsmake2 python3-urllib3
1625   lfsmake2 python3-flit
1626   lfsmake2 python3-packaging
1627   lfsmake2 python3-typing-extensions
1628   lfsmake2 python3-semantic-version
1629   lfsmake2 python3-setuptools-scm
1630   lfsmake2 python3-setuptools-rust
1631   lfsmake2 python3-six
1632   lfsmake2 python3-dateutil
1633   lfsmake2 python3-jmespath
1634   lfsmake2 python3-colorama
1635   lfsmake2 python3-yaml
1636   lfsmake2 python3-s3transfer
1637   lfsmake2 python3-rsa
1638   lfsmake2 python3-pyasn1
1639   lfsmake2 python3-botocore
1640   lfsmake2 python3-cffi
1641   lfsmake2 python3-cryptography
1642   lfsmake2 python3-circuitbreaker
1643   lfsmake2 python3-pytz
1644   lfsmake2 python3-click
1645   lfsmake2 python3-arrow
1646   lfsmake2 python3-terminaltables
1647   lfsmake2 aws-cli
1648   lfsmake2 oci-python-sdk
1649   lfsmake2 oci-cli
1650   lfsmake2 transmission
1651   lfsmake2 mtr
1652   lfsmake2 minidlna
1653   lfsmake2 acpid
1654   lfsmake2 fping
1655   lfsmake2 telnet
1656   lfsmake2 xinetd
1657   lfsmake2 stress
1658   lfsmake2 sarg
1659   lfsmake2 nginx
1660   lfsmake2 sysbench
1661   lfsmake2 strace
1662   lfsmake2 ltrace
1663   lfsmake2 ipfire-netboot
1664   lfsmake2 lcdproc
1665   lfsmake2 keepalived
1666   lfsmake2 ipvsadm
1667   lfsmake2 perl-Carp-Clan
1668   lfsmake2 perl-Date-Calc
1669   lfsmake2 perl-Date-Manip
1670   lfsmake2 perl-File-Tail
1671   lfsmake2 perl-TimeDate
1672   lfsmake2 swatch
1673   lfsmake2 tor
1674   lfsmake2 wavemon
1675   lfsmake2 iptraf-ng
1676   lfsmake2 iotop
1677   lfsmake2 stunnel
1678   lfsmake2 bacula
1679   lfsmake2 perl-Font-TTF
1680   lfsmake2 perl-IO-String
1681   lfsmake2 perl-PDF-API2
1682   lfsmake2 proxy-accounting
1683   lfsmake2 pigz
1684   lfsmake2 tmux
1685   lfsmake2 perl-Text-CSV_XS
1686   lfsmake2 lua
1687   lfsmake2 haproxy
1688   lfsmake2 ipset
1689   lfsmake2 dnsdist
1690   lfsmake2 bird
1691   lfsmake2 libyang
1692   lfsmake2 frr
1693   lfsmake2 dmidecode
1694   lfsmake2 mcelog
1695   lfsmake2 libpciaccess
1696   lfsmake2 libyajl
1697   lfsmake2 libvirt
1698   lfsmake2 libtalloc
1699   lfsmake2 freeradius
1700   lfsmake2 perl-common-sense
1701   lfsmake2 perl-inotify2
1702   lfsmake2 perl-Net-IP
1703   lfsmake2 wio
1704   lfsmake2 iftop
1705   lfsmake2 mdns-repeater
1706   lfsmake2 i2c-tools
1707   lfsmake2 nss-myhostname
1708   lfsmake2 dehydrated
1709   lfsmake2 shairport-sync
1710   lfsmake2 borgbackup
1711   lfsmake2 lmdb
1712   lfsmake2 knot
1713   lfsmake2 spectre-meltdown-checker
1714   lfsmake2 zabbix_agentd
1715   lfsmake2 flashrom
1716   lfsmake2 firmware-update
1717   lfsmake2 tshark
1718   lfsmake2 speedtest-cli
1719   lfsmake2 rfkill
1720   lfsmake2 amazon-ssm-agent
1721   lfsmake2 libloc
1722   lfsmake2 ncdu
1723   lfsmake2 lshw
1724   lfsmake2 socat
1725   lfsmake2 libcdada
1726   lfsmake2 pmacct
1727   lfsmake2 squid-asnbl
1728   lfsmake2 qemu-ga
1729         lfsmake2 gptfdisk
1730 }
1731
1732 buildinstaller() {
1733   # Run installer scripts one by one
1734   LOGFILE="$BASEDIR/log/_build.installer.log"
1735   export LOGFILE
1736   lfsmake2 memtest
1737   lfsmake2 installer
1738   # use toolchain bash for chroot to strip
1739   CUSTOM_PATH="${TOOLS_DIR}/bin" lfsmake2 strip
1740 }
1741
1742 buildpackages() {
1743   LOGFILE="$BASEDIR/log/_build.packages.log"
1744   export LOGFILE
1745   echo "... see detailed log in _build.*.log files" >> $LOGFILE
1746
1747
1748   # Generating list of packages used
1749   print_line "Generating packages list from logs"
1750   rm -f $BASEDIR/doc/packages-list
1751   for i in `ls -1tr $BASEDIR/log/[^_]*`; do
1752         if [ "$i" != "$BASEDIR/log/FILES" -a -n $i ]; then
1753                 echo "* `basename $i`" >>$BASEDIR/doc/packages-list
1754         fi
1755   done
1756   echo "== List of softwares used to build $NAME Version: $VERSION ==" > $BASEDIR/doc/packages-list.txt
1757   grep -v 'configroot$\|img$\|initrd$\|initscripts$\|installer$\|install$\|setup$\|pakfire$\|stage2$\|smp$\|tools$\|tools1$\|tools2$\|.tgz$\|-config$\|_missing_rootfile$\|install1$\|install2$\|pass1$\|pass2$\|pass3$' \
1758         $BASEDIR/doc/packages-list | sort >> $BASEDIR/doc/packages-list.txt
1759   rm -f $BASEDIR/doc/packages-list
1760   # packages-list.txt is ready to be displayed for wiki page
1761   print_status DONE
1762
1763   # Update changelog
1764   cd $BASEDIR
1765   [ -z $GIT_TAG ]  || LAST_TAG=$GIT_TAG
1766   [ -z $LAST_TAG ] || EXT="$LAST_TAG..HEAD"
1767   git log -n 500 --no-merges --pretty=medium --shortstat $EXT > $BASEDIR/doc/ChangeLog
1768
1769   # Create images for install
1770   lfsmake2 cdrom
1771
1772   # Check if there is a loop device for building in virtual environments
1773   modprobe loop 2>/dev/null
1774   if [ $BUILD_IMAGES == 1 ] && ([ -e /dev/loop/0 ] || [ -e /dev/loop0 ] || [ -e "/dev/loop-control" ]); then
1775         lfsmake2 flash-images
1776   fi
1777
1778   mv $LFS/install/images/{*.iso,*.img.xz,*.bz2} $BASEDIR >> $LOGFILE 2>&1
1779
1780   ipfirepackages
1781
1782   cd $BASEDIR
1783
1784   # remove not useable iso on armv6l (needed to build flash images)
1785   [ "${BUILD_ARCH}" = "armv6l" ] && rm -rf *.iso
1786
1787   for i in $(ls *.bz2 *.img.xz *.iso 2>/dev/null); do
1788         md5sum $i > $i.md5
1789   done
1790   cd $PWD
1791
1792   # Cleanup
1793   stdumount
1794   rm -rf $BASEDIR/build/tmp/*
1795
1796   cd $PWD
1797 }
1798
1799 ipfirepackages() {
1800         lfsmake2 core-updates
1801
1802         local i
1803         for i in $(find $BASEDIR/config/rootfiles/packages{/${BUILD_ARCH},} -maxdepth 1 -type f); do
1804                 i=$(basename ${i})
1805                 if [ -e $BASEDIR/lfs/$i ]; then
1806                         ipfiredist $i
1807                 else
1808                         echo -n $i
1809                         print_status SKIP
1810                 fi
1811         done
1812   test -d $BASEDIR/packages || mkdir $BASEDIR/packages
1813   mv -f $LFS/install/packages/* $BASEDIR/packages >> $LOGFILE 2>&1
1814   rm -rf  $BASEDIR/build/install/packages/*
1815 }
1816
1817 while [ $# -gt 0 ]; do
1818         case "${1}" in
1819                 --target=*)
1820                         configure_build "${1#--target=}"
1821                         ;;
1822                 -*)
1823                         exiterror "Unknown configuration option: ${1}"
1824                         ;;
1825                 *)
1826                         # Found a command, so exit options parsing.
1827                         break
1828                         ;;
1829         esac
1830         shift
1831 done
1832
1833 # See what we're supposed to do
1834 case "$1" in
1835 build)
1836         START_TIME="${SECONDS}"
1837
1838         # Clear screen
1839         ${INTERACTIVE} && clear
1840
1841         PACKAGE="$BASEDIR/cache/toolchains/$SNAME-$VERSION-toolchain-$TOOLCHAINVER-${BUILD_ARCH}.tar.zst"
1842         #only restore on a clean disk
1843         if [ ! -e "${BASEDIR}/build${TOOLS_DIR}/.toolchain-successful" ]; then
1844                 if [ ! -n "$PACKAGE" ]; then
1845                         print_build_stage "Full toolchain compilation"
1846                         prepareenv
1847                         buildtoolchain
1848                 else
1849                         PACKAGENAME=${PACKAGE%.tar.zst}
1850                         print_build_stage "Packaged toolchain compilation"
1851                         if [ `md5sum $PACKAGE | awk '{print $1}'` == `cat $PACKAGENAME.md5 | awk '{print $1}'` ]; then
1852                                 zstd -d < "${PACKAGE}" | tar x
1853                                 prepareenv
1854                         else
1855                                 exiterror "$PACKAGENAME md5 did not match, check downloaded package"
1856                         fi
1857                 fi
1858         else
1859                 prepareenv
1860         fi
1861
1862         print_build_stage "Building LFS"
1863         buildbase
1864
1865         print_build_stage "Building IPFire"
1866         buildipfire
1867
1868         print_build_stage "Building installer"
1869         buildinstaller
1870
1871         print_build_stage "Building packages"
1872         buildpackages
1873
1874         print_build_stage "Checking Logfiles for new Files"
1875
1876         cd $BASEDIR
1877         tools/checknewlog.pl
1878         tools/checkrootfiles
1879         cd $PWD
1880
1881         print_build_summary $(( SECONDS - START_TIME ))
1882         ;;
1883 shell)
1884         # enter a shell inside LFS chroot
1885         # may be used to changed kernel settings
1886         prepareenv
1887         entershell
1888         ;;
1889 clean)
1890         print_line "Cleaning build directory..."
1891
1892         for i in `mount | grep $BASEDIR | sed 's/^.*loop=\(.*\))/\1/'`; do
1893                 $LOSETUP -d $i 2>/dev/null
1894         done
1895         #for i in `mount | grep $BASEDIR | cut -d " " -f 1`; do
1896         #       umount $i
1897         #done
1898         stdumount
1899         for i in `seq 0 7`; do
1900                 if ( losetup /dev/loop${i} 2>/dev/null | grep -q "/install/images" ); then
1901                 umount /dev/loop${i}     2>/dev/null;
1902                 losetup -d /dev/loop${i} 2>/dev/null;
1903                 fi;
1904         done
1905         rm -rf $BASEDIR/build
1906         rm -rf $BASEDIR/cdrom
1907         rm -rf $BASEDIR/packages
1908         rm -rf $BASEDIR/log
1909         if [ -h "${TOOLS_DIR}" ]; then
1910                 rm -f "${TOOLS_DIR}"
1911         fi
1912         rm -f $BASEDIR/ipfire-*
1913         print_status DONE
1914         ;;
1915 docker)
1916         # Build the docker image if it does not exist, yet
1917         if ! docker images -a | grep -q ^ipfire-builder; then
1918                 if docker build -t ipfire-builder ${BASEDIR}/tools/docker; then
1919                         print_status DONE
1920                 else
1921                         print_status FAIL
1922                         exit 1
1923                 fi
1924         fi
1925
1926         # Run the container and enter a shell
1927         docker run -it --privileged -v "${BASEDIR}:/build" -w "/build" ipfire-builder bash -l
1928         ;;
1929 downloadsrc)
1930         if [ ! -d $BASEDIR/cache ]; then
1931                 mkdir $BASEDIR/cache
1932         fi
1933         mkdir -p $BASEDIR/log
1934         echo -e "${BOLD}Preload all source files${NORMAL}" | tee -a $LOGFILE
1935         FINISHED=0
1936         cd $BASEDIR/lfs
1937         for c in `seq $MAX_RETRIES`; do
1938                 if (( FINISHED==1 )); then
1939                         break
1940                 fi
1941                 FINISHED=1
1942                 cd $BASEDIR/lfs
1943                 for i in *; do
1944                         if [ -f "$i" -a "$i" != "Config" ]; then
1945                                 lfsmakecommoncheck ${i} || continue
1946
1947                                 make -s -f $i LFS_BASEDIR=$BASEDIR BUILD_ARCH="${BUILD_ARCH}" \
1948                                         MESSAGE="$i\t ($c/$MAX_RETRIES)" download >> $LOGFILE 2>&1
1949                                 if [ $? -ne 0 ]; then
1950                                         print_status FAIL
1951                                         FINISHED=0
1952                                 else
1953                                         if [ $c -eq 1 ]; then
1954                                         print_status DONE
1955                                         fi
1956                                 fi
1957                         fi
1958                 done
1959         done
1960         echo -e "${BOLD}***Verifying md5sums${NORMAL}"
1961         ERROR=0
1962         for i in *; do
1963                 if [ -f "$i" -a "$i" != "Config" ]; then
1964                         lfsmakecommoncheck ${i} > /dev/null || continue
1965                         make -s -f $i LFS_BASEDIR=$BASEDIR BUILD_ARCH="${BUILD_ARCH}" \
1966                                 MESSAGE="$i\t " md5 >> $LOGFILE 2>&1
1967                         if [ $? -ne 0 ]; then
1968                                 echo -ne "MD5 difference in lfs/$i"
1969                                 print_status FAIL
1970                                 ERROR=1
1971                         fi
1972                 fi
1973         done
1974         if [ $ERROR -eq 0 ]; then
1975                 echo -ne "${BOLD}all files md5sum match${NORMAL}"
1976                 print_status DONE
1977         else
1978                 echo -ne "${BOLD}not all files were correctly download${NORMAL}"
1979                 print_status FAIL
1980         fi
1981         cd - >/dev/null 2>&1
1982         ;;
1983 toolchain)
1984         # Clear screen
1985         ${INTERACTIVE} && clear
1986
1987         prepareenv
1988         print_build_stage "Toolchain compilation (${BUILD_ARCH})"
1989         buildtoolchain
1990         echo "`date -u '+%b %e %T'`: Create toolchain image for ${BUILD_ARCH}" | tee -a $LOGFILE
1991         test -d $BASEDIR/cache/toolchains || mkdir -p $BASEDIR/cache/toolchains
1992         cd $BASEDIR && tar -cf- --exclude='log/_build.*.log' build/${TOOLS_DIR} build/bin/sh log \
1993                 | zstd ${ZSTD_OPT} > cache/toolchains/$SNAME-$VERSION-toolchain-$TOOLCHAINVER-${BUILD_ARCH}.tar.zst
1994         md5sum cache/toolchains/$SNAME-$VERSION-toolchain-$TOOLCHAINVER-${BUILD_ARCH}.tar.zst \
1995                 > cache/toolchains/$SNAME-$VERSION-toolchain-$TOOLCHAINVER-${BUILD_ARCH}.md5
1996         stdumount
1997         ;;
1998 gettoolchain)
1999         # arbitrary name to be updated in case of new toolchain package upload
2000         PACKAGE=$SNAME-$VERSION-toolchain-$TOOLCHAINVER-${BUILD_ARCH}
2001         if [ ! -f $BASEDIR/cache/toolchains/$PACKAGE.tar.zst ]; then
2002                 URL_TOOLCHAIN=`grep URL_TOOLCHAIN lfs/Config | awk '{ print $3 }'`
2003                 test -d $BASEDIR/cache/toolchains || mkdir -p $BASEDIR/cache/toolchains
2004                 echo "`date -u '+%b %e %T'`: Load toolchain image for ${BUILD_ARCH}" | tee -a $LOGFILE
2005                 cd $BASEDIR/cache/toolchains
2006                 wget -U "IPFireSourceGrabber/2.x" $URL_TOOLCHAIN/$PACKAGE.tar.zst $URL_TOOLCHAIN/$PACKAGE.md5 >& /dev/null
2007                 if [ $? -ne 0 ]; then
2008                         echo "`date -u '+%b %e %T'`: error downloading $PACKAGE toolchain for ${BUILD_ARCH} machine" | tee -a $LOGFILE
2009                 else
2010                         if [ "`md5sum $PACKAGE.tar.zst | awk '{print $1}'`" = "`cat $PACKAGE.md5 | awk '{print $1}'`" ]; then
2011                                 echo "`date -u '+%b %e %T'`: toolchain md5 ok" | tee -a $LOGFILE
2012                         else
2013                                 exiterror "$PACKAGE.md5 did not match, check downloaded package"
2014                         fi
2015                 fi
2016         else
2017                 echo "Toolchain is already downloaded. Exiting..."
2018         fi
2019         ;;
2020 uploadsrc)
2021         if [ -z $IPFIRE_USER ]; then
2022                 echo -n "You have to setup IPFIRE_USER first. See .config for details."
2023                 print_status FAIL
2024                 exit 1
2025         fi
2026
2027         URL_SOURCE="$(awk '/^URL_SOURCE/ { print $3 }' lfs/Config)"
2028
2029         rsync \
2030                 --recursive \
2031                 --update \
2032                 --ignore-existing \
2033                 --progress \
2034                 --human-readable \
2035                 --exclude="toolchains/" \
2036                 "${BASEDIR}/cache/" \
2037                 "${IPFIRE_USER}@${URL_SOURCE}"
2038
2039         exit 0
2040         ;;
2041 lang)
2042         echo -ne "Checking the translations for missing or obsolete strings..."
2043         chmod 755 $BASEDIR/tools/{check_strings.pl,sort_strings.pl,check_langs.sh}
2044         $BASEDIR/tools/sort_strings.pl en
2045         $BASEDIR/tools/sort_strings.pl de
2046         $BASEDIR/tools/sort_strings.pl fr
2047         $BASEDIR/tools/sort_strings.pl es
2048         $BASEDIR/tools/sort_strings.pl pl
2049         $BASEDIR/tools/sort_strings.pl ru
2050         $BASEDIR/tools/sort_strings.pl nl
2051         $BASEDIR/tools/sort_strings.pl tr
2052         $BASEDIR/tools/sort_strings.pl it
2053         $BASEDIR/tools/check_strings.pl en > $BASEDIR/doc/language_issues.en
2054         $BASEDIR/tools/check_strings.pl de > $BASEDIR/doc/language_issues.de
2055         $BASEDIR/tools/check_strings.pl fr > $BASEDIR/doc/language_issues.fr
2056         $BASEDIR/tools/check_strings.pl es > $BASEDIR/doc/language_issues.es
2057         $BASEDIR/tools/check_strings.pl pl > $BASEDIR/doc/language_issues.pl
2058         $BASEDIR/tools/check_strings.pl ru > $BASEDIR/doc/language_issues.ru
2059         $BASEDIR/tools/check_strings.pl nl > $BASEDIR/doc/language_issues.nl
2060         $BASEDIR/tools/check_strings.pl tr > $BASEDIR/doc/language_issues.tr
2061         $BASEDIR/tools/check_strings.pl it > $BASEDIR/doc/language_issues.it
2062         $BASEDIR/tools/check_langs.sh > $BASEDIR/doc/language_missings
2063         print_status DONE
2064
2065         echo -ne "Updating language lists..."
2066         update_language_list ${BASEDIR}/src/installer/po
2067         update_language_list ${BASEDIR}/src/setup/po
2068         print_status DONE
2069         ;;
2070 update-contributors)
2071         update_contributors
2072         ;;
2073 find-dependencies)
2074         shift
2075         exec "${BASEDIR}/tools/find-dependencies" "${BASEDIR}/build" "$@"
2076         ;;
2077 check-manualpages)
2078         echo "Checking the manual pages for broken links..."
2079
2080         chmod 755 $BASEDIR/tools/check_manualpages.pl
2081         if $BASEDIR/tools/check_manualpages.pl; then
2082                 print_status DONE
2083         else
2084                 print_status FAIL
2085         fi
2086         ;;
2087 *)
2088         echo "Usage: $0 [OPTIONS] {build|changelog|clean|gettoolchain|downloadsrc|shell|sync|toolchain|update-contributors|find-dependencies|check-manualpages}"
2089         cat doc/make.sh-usage
2090         ;;
2091 esac