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 rtl8812au            KCFG=""
1199   lfsmake2 rtl8822bu            KCFG=""
1200   lfsmake2 xradio               KCFG=""
1201   lfsmake2 linux-initrd         KCFG=""
1202
1203   lfsmake2 libgpg-error
1204   lfsmake2 libgcrypt
1205   lfsmake2 libassuan
1206   lfsmake2 nettle
1207   lfsmake2 json-c
1208   lfsmake2 libconfig
1209   lfsmake2 libevent
1210   lfsmake2 libevent2
1211   lfsmake2 expat
1212   lfsmake2 apr
1213   lfsmake2 aprutil
1214   lfsmake2 unbound
1215   lfsmake2 gnutls
1216   lfsmake2 libuv
1217   lfsmake2 bind
1218   lfsmake2 dhcp
1219   lfsmake2 dhcpcd
1220   lfsmake2 boost
1221   lfsmake2 linux-atm
1222   lfsmake2 gdbm
1223   lfsmake2 pam
1224   lfsmake2 c-ares
1225   lfsmake2 curl
1226   lfsmake2 tcl
1227   lfsmake2 sqlite
1228   lfsmake2 libffi
1229   lfsmake2 python3
1230   lfsmake2 rust
1231   lfsmake2 rust-dissimilar
1232   lfsmake2 rust-cfg-if
1233   lfsmake2 rust-libc
1234   lfsmake2 rust-getrandom
1235   lfsmake2 rust-typenum
1236   lfsmake2 rust-version-check
1237   lfsmake2 rust-generic-array
1238   lfsmake2 rust-cipher
1239   lfsmake2 rust-hex
1240   lfsmake2 rust-unicode-xid
1241   lfsmake2 rust-proc-macro2
1242   lfsmake2 rust-quote
1243   lfsmake2 rust-syn
1244   lfsmake2 rust-home
1245   lfsmake2 rust-lazy-static
1246   lfsmake2 rust-memchr
1247   lfsmake2 rust-aho-corasick
1248   lfsmake2 rust-regex-syntax
1249   lfsmake2 rust-regex
1250   lfsmake2 rust-ucd-trie
1251   lfsmake2 rust-pest
1252   lfsmake2 rust-semver-parser
1253   lfsmake2 rust-semver
1254   lfsmake2 rust-same-file
1255   lfsmake2 rust-walkdir
1256   lfsmake2 rust-dirs
1257   lfsmake2 rust-toolchain_find
1258   lfsmake2 rust-serde
1259   lfsmake2 rust-itoa
1260   lfsmake2 rust-ryu
1261   lfsmake2 rust-serde_json
1262   lfsmake2 rust-synstructure
1263   lfsmake2 rust-block-buffer
1264   lfsmake2 rust-crypto-common
1265   lfsmake2 rust-digest
1266   lfsmake2 rust-ppv-lite86
1267   lfsmake2 rust-rand_core
1268   lfsmake2 rust-rand_core-0.4.2
1269   lfsmake2 rust-rand_core-0.3.1
1270   lfsmake2 rust-rand_chacha
1271   lfsmake2 rust-rand_hc
1272   lfsmake2 rust-rand
1273   lfsmake2 rust-rdrand
1274   lfsmake2 rust-rand-0.4
1275   lfsmake2 rust-log
1276   lfsmake2 rust-num_cpus
1277   lfsmake2 rust-crossbeam-utils
1278   lfsmake2 rust-autocfg
1279   lfsmake2 rust-memoffset
1280   lfsmake2 rust-scopeguard
1281   lfsmake2 rust-crossbeam-epoch
1282   lfsmake2 rust-crossbeam-deque
1283   lfsmake2 rust-either
1284   lfsmake2 rust-crossbeam-channel
1285   lfsmake2 rust-rayon-core
1286   lfsmake2 rust-rayon
1287   lfsmake2 rust-remove_dir_all
1288   lfsmake2 rust-tempdir
1289   lfsmake2 rust-glob
1290   lfsmake2 rust-once_cell
1291   lfsmake2 rust-termcolor
1292   lfsmake2 rust-toml
1293   lfsmake2 rust-serde_derive
1294   lfsmake2 rust-trybuild
1295   lfsmake2 rust-unindent
1296   lfsmake2 rust-proc-macro-hack
1297   lfsmake2 rust-indoc-impl
1298   lfsmake2 rust-indoc
1299   lfsmake2 rust-instant
1300   lfsmake2 rust-lock_api
1301   lfsmake2 rust-smallvec
1302   lfsmake2 rust-parking_lot_core
1303   lfsmake2 rust-parking_lot
1304   lfsmake2 rust-paste-impl
1305   lfsmake2 rust-paste
1306   lfsmake2 rust-ctor
1307   lfsmake2 rust-ghost
1308   lfsmake2 rust-inventory-impl
1309   lfsmake2 rust-inventory
1310   lfsmake2 rust-pyo3-build-config
1311   lfsmake2 rust-pyo3-macros-backend
1312   lfsmake2 rust-pyo3-macros
1313   lfsmake2 rust-pyo3
1314   lfsmake2 gdb
1315   lfsmake2 grub
1316   lfsmake2 efivar
1317   lfsmake2 efibootmgr
1318   lfsmake2 libtasn1
1319   lfsmake2 p11-kit
1320   lfsmake2 ca-certificates
1321   lfsmake2 fireinfo
1322   lfsmake2 libnet
1323   lfsmake2 libnl
1324   lfsmake2 libnl-3
1325   lfsmake2 libidn
1326   lfsmake2 nasm
1327   lfsmake2 libarchive
1328   lfsmake2 cmake
1329   lfsmake2 ninja
1330   lfsmake2 meson
1331   lfsmake2 libjpeg
1332   lfsmake2 openjpeg
1333   lfsmake2 libexif
1334   lfsmake2 libpng
1335   lfsmake2 libtiff
1336   lfsmake2 libart
1337   lfsmake2 gd
1338   lfsmake2 slang
1339   lfsmake2 newt
1340   lfsmake2 libsmooth
1341   lfsmake2 libcap
1342   lfsmake2 libcap-ng
1343   lfsmake2 pciutils
1344   lfsmake2 usbutils
1345   lfsmake2 libxml2
1346   lfsmake2 libxslt
1347   lfsmake2 perl-BerkeleyDB
1348   lfsmake2 cyrus-sasl
1349   lfsmake2 openldap
1350   lfsmake2 apache2
1351   lfsmake2 web-user-interface
1352   lfsmake2 flag-icons
1353   lfsmake2 jquery
1354   lfsmake2 bootstrap
1355   lfsmake2 arping
1356   lfsmake2 beep
1357   lfsmake2 libssh
1358   lfsmake2 libinih
1359   lfsmake2 cdrkit
1360   lfsmake2 dosfstools
1361   lfsmake2 exfatprogs
1362   lfsmake2 reiserfsprogs
1363   lfsmake2 liburcu
1364   lfsmake2 xfsprogs
1365   lfsmake2 sysfsutils
1366   lfsmake2 fuse
1367   lfsmake2 ntfs-3g
1368   lfsmake2 ethtool
1369   lfsmake2 fcron
1370   lfsmake2 perl-ExtUtils-PkgConfig
1371   lfsmake2 perl-GD
1372   lfsmake2 perl-GD-Graph
1373   lfsmake2 perl-GD-TextUtil
1374   lfsmake2 perl-Device-SerialPort
1375   lfsmake2 perl-Device-Modem
1376   lfsmake2 perl-Apache-Htpasswd
1377   lfsmake2 perl-Parse-Yapp
1378   lfsmake2 perl-Data-UUID
1379   lfsmake2 perl-Try-Tiny
1380   lfsmake2 perl-HTTP-Message
1381   lfsmake2 perl-HTTP-Date
1382   lfsmake2 gnupg
1383   lfsmake2 hdparm
1384   lfsmake2 sdparm
1385   lfsmake2 whatmask
1386   lfsmake2 libtirpc
1387   lfsmake2 conntrack-tools
1388   lfsmake2 iputils
1389   lfsmake2 l7-protocols
1390   lfsmake2 hwdata
1391   lfsmake2 logrotate
1392   lfsmake2 logwatch
1393   lfsmake2 misc-progs
1394   lfsmake2 nano
1395   lfsmake2 perl-URI
1396   lfsmake2 perl-CGI
1397   lfsmake2 perl-Switch
1398   lfsmake2 perl-HTML-Tagset
1399   lfsmake2 perl-HTML-Parser
1400   lfsmake2 perl-HTML-Template
1401   lfsmake2 perl-Compress-Zlib
1402   lfsmake2 perl-Digest
1403   lfsmake2 perl-Digest-SHA1
1404   lfsmake2 perl-Digest-HMAC
1405   lfsmake2 perl-libwww
1406         lfsmake2 perl-LWP-Protocol-https
1407   lfsmake2 perl-Net-HTTP
1408   lfsmake2 perl-Net-DNS
1409   lfsmake2 perl-Net-IPv4Addr
1410   lfsmake2 perl-Net_SSLeay
1411   lfsmake2 perl-IO-Stringy
1412   lfsmake2 perl-IO-Socket-SSL
1413   lfsmake2 perl-Unix-Syslog
1414   lfsmake2 perl-Mail-Tools
1415   lfsmake2 perl-MIME-Tools
1416   lfsmake2 perl-Net-Server
1417   lfsmake2 perl-Canary-Stability
1418   lfsmake2 perl-Convert-TNEF
1419   lfsmake2 perl-Convert-UUlib
1420   lfsmake2 perl-Archive-Tar
1421   lfsmake2 perl-Archive-Zip
1422   lfsmake2 perl-Text-Tabs+Wrap
1423   lfsmake2 perl-XML-Parser
1424   lfsmake2 perl-Crypt-PasswdMD5
1425   lfsmake2 perl-Net-Telnet
1426   lfsmake2 python3-setuptools
1427   lfsmake2 python3-inotify
1428   lfsmake2 python3-docutils
1429   lfsmake2 python3-daemon
1430   lfsmake2 glib
1431   lfsmake2 ntp
1432   lfsmake2 openssh
1433   lfsmake2 fontconfig
1434   lfsmake2 dejavu-fonts-ttf
1435   lfsmake2 ubuntu-font-family
1436   lfsmake2 freefont
1437   lfsmake2 pixman
1438   lfsmake2 cairo
1439   lfsmake2 harfbuzz
1440   lfsmake2 fribidi
1441   lfsmake2 pango
1442   lfsmake2 rrdtool
1443   lfsmake2 setup
1444   lfsmake2 libdnet
1445   lfsmake2 jansson
1446   lfsmake2 yaml
1447   lfsmake2 libhtp
1448   lfsmake2 colm
1449   lfsmake2 ragel
1450   lfsmake2 hyperscan
1451   lfsmake2 suricata
1452   lfsmake2 oinkmaster
1453   lfsmake2 ids-ruleset-sources
1454   lfsmake2 squid
1455   lfsmake2 squidguard
1456   lfsmake2 calamaris
1457   lfsmake2 tcpdump
1458   lfsmake2 traceroute
1459   lfsmake2 vlan
1460   lfsmake2 wireless
1461   lfsmake2 pakfire
1462   lfsmake2 spandsp
1463   lfsmake2 lz4
1464   lfsmake2 lzo
1465   lfsmake2 openvpn
1466   lfsmake2 mpage
1467   lfsmake2 dbus
1468   lfsmake2 intltool
1469   lfsmake2 libdaemon
1470   lfsmake2 avahi
1471   lfsmake2 cups
1472   lfsmake2 lcms2
1473   lfsmake2 ghostscript
1474   lfsmake2 qpdf
1475   lfsmake2 poppler
1476   lfsmake2 poppler-data
1477   lfsmake2 cups-filters
1478   lfsmake2 epson-inkjet-printer-escpr
1479   lfsmake2 foomatic
1480   lfsmake2 hplip
1481   lfsmake2 cifs-utils
1482   lfsmake2 krb5
1483   lfsmake2 rpcsvc-proto
1484   lfsmake2 samba
1485   lfsmake2 netatalk
1486   lfsmake2 sudo
1487   lfsmake2 mc
1488   lfsmake2 wget
1489   lfsmake2 bridge-utils
1490   lfsmake2 smartmontools
1491   lfsmake2 htop
1492   lfsmake2 chkconfig
1493   lfsmake2 postfix
1494   lfsmake2 fetchmail
1495   lfsmake2 clamav
1496   lfsmake2 perl-NetAddr-IP
1497   lfsmake2 dma
1498   lfsmake2 alsa
1499   lfsmake2 mpfire
1500   lfsmake2 guardian
1501   lfsmake2 libid3tag
1502   lfsmake2 libmad
1503   lfsmake2 libogg
1504   lfsmake2 libvorbis
1505   lfsmake2 flac
1506   lfsmake2 lame
1507   lfsmake2 sox
1508   lfsmake2 soxr
1509   lfsmake2 libshout
1510   lfsmake2 xvid
1511   lfsmake2 libmpeg2
1512   lfsmake2 gnump3d
1513   lfsmake2 rsync
1514   lfsmake2 rpcbind
1515   lfsmake2 keyutils
1516   lfsmake2 nfs
1517   lfsmake2 gnu-netcat
1518   lfsmake2 ncat
1519   lfsmake2 nmap
1520   lfsmake2 etherwake
1521   lfsmake2 bwm-ng
1522   lfsmake2 sysstat
1523   lfsmake2 strongswan
1524   lfsmake2 rng-tools
1525   lfsmake2 lsof
1526   lfsmake2 br2684ctl
1527   lfsmake2 pcmciautils
1528   lfsmake2 lm_sensors
1529   lfsmake2 libstatgrab
1530   lfsmake2 liboping
1531   lfsmake2 collectd
1532   lfsmake2 elinks
1533   lfsmake2 igmpproxy
1534   lfsmake2 opus
1535   lfsmake2 python3-pyparsing
1536   lfsmake2 spice-protocol
1537   lfsmake2 spice
1538   lfsmake2 sdl2
1539   lfsmake2 libusbredir
1540   lfsmake2 libseccomp
1541   lfsmake2 qemu
1542   lfsmake2 netpbm
1543   lfsmake2 netsnmpd
1544   lfsmake2 nagios_nrpe
1545   lfsmake2 nagios-plugins
1546   lfsmake2 icinga
1547   lfsmake2 observium-agent
1548   lfsmake2 ebtables
1549   lfsmake2 faad2
1550   lfsmake2 alac
1551   lfsmake2 ffmpeg
1552   lfsmake2 vdr
1553   lfsmake2 vdr_streamdev
1554   lfsmake2 vdr_epgsearch
1555   lfsmake2 vdr_dvbapi
1556   lfsmake2 vdr_eepg
1557   lfsmake2 w_scan
1558   lfsmake2 mpd
1559   lfsmake2 libmpdclient
1560   lfsmake2 mpc
1561   lfsmake2 perl-Net-CIDR-Lite
1562   lfsmake2 perl-Net-SMTP-SSL
1563   lfsmake2 perl-MIME-Base64
1564   lfsmake2 perl-Authen-SASL
1565   lfsmake2 perl-MIME-Lite
1566   lfsmake2 perl-Email-Date-Format
1567   lfsmake2 git
1568   lfsmake2 squidclamav
1569   lfsmake2 vnstat
1570   lfsmake2 iw
1571   lfsmake2 wpa_supplicant
1572   lfsmake2 hostapd
1573   lfsmake2 syslinux
1574   lfsmake2 tftpd
1575   lfsmake2 cpufrequtils
1576   lfsmake2 gutenprint
1577   lfsmake2 apcupsd
1578   lfsmake2 fireperf
1579   lfsmake2 iperf
1580   lfsmake2 iperf3
1581   lfsmake2 7zip
1582   lfsmake2 lynis
1583   lfsmake2 sshfs
1584   lfsmake2 taglib
1585   lfsmake2 sslh
1586   lfsmake2 perl-gettext
1587   lfsmake2 perl-Sort-Naturally
1588   lfsmake2 vdradmin
1589   lfsmake2 perl-DBI
1590   lfsmake2 perl-DBD-SQLite
1591   lfsmake2 perl-File-ReadBackwards
1592   lfsmake2 openvmtools
1593   lfsmake2 joe
1594   lfsmake2 monit
1595   lfsmake2 nut
1596   lfsmake2 watchdog
1597   lfsmake2 libpri
1598   lfsmake2 usb_modeswitch
1599   lfsmake2 usb_modeswitch_data
1600   lfsmake2 zerofree
1601   lfsmake2 minicom
1602   lfsmake2 ddrescue
1603   lfsmake2 powertop
1604   lfsmake2 parted
1605   lfsmake2 swig
1606   lfsmake2 dtc
1607   lfsmake2 u-boot
1608   lfsmake2 u-boot-friendlyarm
1609   lfsmake2 wireless-regdb
1610   lfsmake2 libsolv
1611   lfsmake2 ddns
1612   lfsmake2 python3-pycparser
1613   lfsmake2 python3-charset-normalizer
1614   lfsmake2 python3-certifi
1615   lfsmake2 python3-idna
1616   lfsmake2 python3-requests
1617   lfsmake2 python3-toml
1618   lfsmake2 python3-pyproject2setuppy
1619   lfsmake2 python3-tomli
1620   lfsmake2 python3-pep517
1621   lfsmake2 python3-build
1622   lfsmake2 python3-install
1623   lfsmake2 python3-urllib3
1624   lfsmake2 python3-flit
1625   lfsmake2 python3-packaging
1626   lfsmake2 python3-typing-extensions
1627   lfsmake2 python3-semantic-version
1628   lfsmake2 python3-setuptools-scm
1629   lfsmake2 python3-setuptools-rust
1630   lfsmake2 python3-six
1631   lfsmake2 python3-dateutil
1632   lfsmake2 python3-jmespath
1633   lfsmake2 python3-colorama
1634   lfsmake2 python3-yaml
1635   lfsmake2 python3-s3transfer
1636   lfsmake2 python3-rsa
1637   lfsmake2 python3-pyasn1
1638   lfsmake2 python3-botocore
1639   lfsmake2 python3-cffi
1640   lfsmake2 python3-cryptography
1641   lfsmake2 python3-circuitbreaker
1642   lfsmake2 python3-pytz
1643   lfsmake2 python3-click
1644   lfsmake2 python3-arrow
1645   lfsmake2 python3-terminaltables
1646   lfsmake2 aws-cli
1647   lfsmake2 oci-python-sdk
1648   lfsmake2 oci-cli
1649   lfsmake2 transmission
1650   lfsmake2 mtr
1651   lfsmake2 minidlna
1652   lfsmake2 acpid
1653   lfsmake2 fping
1654   lfsmake2 telnet
1655   lfsmake2 xinetd
1656   lfsmake2 stress
1657   lfsmake2 sarg
1658   lfsmake2 nginx
1659   lfsmake2 sysbench
1660   lfsmake2 strace
1661   lfsmake2 ltrace
1662   lfsmake2 ipfire-netboot
1663   lfsmake2 lcdproc
1664   lfsmake2 keepalived
1665   lfsmake2 ipvsadm
1666   lfsmake2 perl-Carp-Clan
1667   lfsmake2 perl-Date-Calc
1668   lfsmake2 perl-Date-Manip
1669   lfsmake2 perl-File-Tail
1670   lfsmake2 perl-TimeDate
1671   lfsmake2 swatch
1672   lfsmake2 tor
1673   lfsmake2 wavemon
1674   lfsmake2 iptraf-ng
1675   lfsmake2 iotop
1676   lfsmake2 stunnel
1677   lfsmake2 bacula
1678   lfsmake2 perl-Font-TTF
1679   lfsmake2 perl-IO-String
1680   lfsmake2 perl-PDF-API2
1681   lfsmake2 proxy-accounting
1682   lfsmake2 pigz
1683   lfsmake2 tmux
1684   lfsmake2 perl-Text-CSV_XS
1685   lfsmake2 lua
1686   lfsmake2 haproxy
1687   lfsmake2 ipset
1688   lfsmake2 dnsdist
1689   lfsmake2 bird
1690   lfsmake2 libyang
1691   lfsmake2 frr
1692   lfsmake2 dmidecode
1693   lfsmake2 mcelog
1694   lfsmake2 libpciaccess
1695   lfsmake2 libyajl
1696   lfsmake2 libvirt
1697   lfsmake2 libtalloc
1698   lfsmake2 freeradius
1699   lfsmake2 perl-common-sense
1700   lfsmake2 perl-inotify2
1701   lfsmake2 perl-Net-IP
1702   lfsmake2 wio
1703   lfsmake2 iftop
1704   lfsmake2 mdns-repeater
1705   lfsmake2 i2c-tools
1706   lfsmake2 nss-myhostname
1707   lfsmake2 dehydrated
1708   lfsmake2 shairport-sync
1709   lfsmake2 borgbackup
1710   lfsmake2 lmdb
1711   lfsmake2 knot
1712   lfsmake2 spectre-meltdown-checker
1713   lfsmake2 zabbix_agentd
1714   lfsmake2 flashrom
1715   lfsmake2 firmware-update
1716   lfsmake2 tshark
1717   lfsmake2 speedtest-cli
1718   lfsmake2 rfkill
1719   lfsmake2 amazon-ssm-agent
1720   lfsmake2 libloc
1721   lfsmake2 ncdu
1722   lfsmake2 lshw
1723   lfsmake2 socat
1724   lfsmake2 libcdada
1725   lfsmake2 pmacct
1726   lfsmake2 squid-asnbl
1727   lfsmake2 qemu-ga
1728         lfsmake2 gptfdisk
1729 }
1730
1731 buildinstaller() {
1732   # Run installer scripts one by one
1733   LOGFILE="$BASEDIR/log/_build.installer.log"
1734   export LOGFILE
1735   lfsmake2 memtest
1736   lfsmake2 installer
1737   # use toolchain bash for chroot to strip
1738   CUSTOM_PATH="${TOOLS_DIR}/bin" lfsmake2 strip
1739 }
1740
1741 buildpackages() {
1742   LOGFILE="$BASEDIR/log/_build.packages.log"
1743   export LOGFILE
1744   echo "... see detailed log in _build.*.log files" >> $LOGFILE
1745
1746
1747   # Generating list of packages used
1748   print_line "Generating packages list from logs"
1749   rm -f $BASEDIR/doc/packages-list
1750   for i in `ls -1tr $BASEDIR/log/[^_]*`; do
1751         if [ "$i" != "$BASEDIR/log/FILES" -a -n $i ]; then
1752                 echo "* `basename $i`" >>$BASEDIR/doc/packages-list
1753         fi
1754   done
1755   echo "== List of softwares used to build $NAME Version: $VERSION ==" > $BASEDIR/doc/packages-list.txt
1756   grep -v 'configroot$\|img$\|initrd$\|initscripts$\|installer$\|install$\|setup$\|pakfire$\|stage2$\|smp$\|tools$\|tools1$\|tools2$\|.tgz$\|-config$\|_missing_rootfile$\|install1$\|install2$\|pass1$\|pass2$\|pass3$' \
1757         $BASEDIR/doc/packages-list | sort >> $BASEDIR/doc/packages-list.txt
1758   rm -f $BASEDIR/doc/packages-list
1759   # packages-list.txt is ready to be displayed for wiki page
1760   print_status DONE
1761
1762   # Update changelog
1763   cd $BASEDIR
1764   [ -z $GIT_TAG ]  || LAST_TAG=$GIT_TAG
1765   [ -z $LAST_TAG ] || EXT="$LAST_TAG..HEAD"
1766   git log -n 500 --no-merges --pretty=medium --shortstat $EXT > $BASEDIR/doc/ChangeLog
1767
1768   # Create images for install
1769   lfsmake2 cdrom
1770
1771   # Check if there is a loop device for building in virtual environments
1772   modprobe loop 2>/dev/null
1773   if [ $BUILD_IMAGES == 1 ] && ([ -e /dev/loop/0 ] || [ -e /dev/loop0 ] || [ -e "/dev/loop-control" ]); then
1774         lfsmake2 flash-images
1775   fi
1776
1777   mv $LFS/install/images/{*.iso,*.img.xz,*.bz2} $BASEDIR >> $LOGFILE 2>&1
1778
1779   ipfirepackages
1780
1781   cd $BASEDIR
1782
1783   # remove not useable iso on armv6l (needed to build flash images)
1784   [ "${BUILD_ARCH}" = "armv6l" ] && rm -rf *.iso
1785
1786   for i in $(ls *.bz2 *.img.xz *.iso 2>/dev/null); do
1787         md5sum $i > $i.md5
1788   done
1789   cd $PWD
1790
1791   # Cleanup
1792   stdumount
1793   rm -rf $BASEDIR/build/tmp/*
1794
1795   cd $PWD
1796 }
1797
1798 ipfirepackages() {
1799         lfsmake2 core-updates
1800
1801         local i
1802         for i in $(find $BASEDIR/config/rootfiles/packages{/${BUILD_ARCH},} -maxdepth 1 -type f); do
1803                 i=$(basename ${i})
1804                 if [ -e $BASEDIR/lfs/$i ]; then
1805                         ipfiredist $i
1806                 else
1807                         echo -n $i
1808                         print_status SKIP
1809                 fi
1810         done
1811   test -d $BASEDIR/packages || mkdir $BASEDIR/packages
1812   mv -f $LFS/install/packages/* $BASEDIR/packages >> $LOGFILE 2>&1
1813   rm -rf  $BASEDIR/build/install/packages/*
1814 }
1815
1816 while [ $# -gt 0 ]; do
1817         case "${1}" in
1818                 --target=*)
1819                         configure_build "${1#--target=}"
1820                         ;;
1821                 -*)
1822                         exiterror "Unknown configuration option: ${1}"
1823                         ;;
1824                 *)
1825                         # Found a command, so exit options parsing.
1826                         break
1827                         ;;
1828         esac
1829         shift
1830 done
1831
1832 # See what we're supposed to do
1833 case "$1" in
1834 build)
1835         START_TIME="${SECONDS}"
1836
1837         # Clear screen
1838         ${INTERACTIVE} && clear
1839
1840         PACKAGE="$BASEDIR/cache/toolchains/$SNAME-$VERSION-toolchain-$TOOLCHAINVER-${BUILD_ARCH}.tar.zst"
1841         #only restore on a clean disk
1842         if [ ! -e "${BASEDIR}/build${TOOLS_DIR}/.toolchain-successful" ]; then
1843                 if [ ! -n "$PACKAGE" ]; then
1844                         print_build_stage "Full toolchain compilation"
1845                         prepareenv
1846                         buildtoolchain
1847                 else
1848                         PACKAGENAME=${PACKAGE%.tar.zst}
1849                         print_build_stage "Packaged toolchain compilation"
1850                         if [ `md5sum $PACKAGE | awk '{print $1}'` == `cat $PACKAGENAME.md5 | awk '{print $1}'` ]; then
1851                                 zstd -d < "${PACKAGE}" | tar x
1852                                 prepareenv
1853                         else
1854                                 exiterror "$PACKAGENAME md5 did not match, check downloaded package"
1855                         fi
1856                 fi
1857         else
1858                 prepareenv
1859         fi
1860
1861         print_build_stage "Building LFS"
1862         buildbase
1863
1864         print_build_stage "Building IPFire"
1865         buildipfire
1866
1867         print_build_stage "Building installer"
1868         buildinstaller
1869
1870         print_build_stage "Building packages"
1871         buildpackages
1872
1873         print_build_stage "Checking Logfiles for new Files"
1874
1875         cd $BASEDIR
1876         tools/checknewlog.pl
1877         tools/checkrootfiles
1878         cd $PWD
1879
1880         print_build_summary $(( SECONDS - START_TIME ))
1881         ;;
1882 shell)
1883         # enter a shell inside LFS chroot
1884         # may be used to changed kernel settings
1885         prepareenv
1886         entershell
1887         ;;
1888 clean)
1889         print_line "Cleaning build directory..."
1890
1891         for i in `mount | grep $BASEDIR | sed 's/^.*loop=\(.*\))/\1/'`; do
1892                 $LOSETUP -d $i 2>/dev/null
1893         done
1894         #for i in `mount | grep $BASEDIR | cut -d " " -f 1`; do
1895         #       umount $i
1896         #done
1897         stdumount
1898         for i in `seq 0 7`; do
1899                 if ( losetup /dev/loop${i} 2>/dev/null | grep -q "/install/images" ); then
1900                 umount /dev/loop${i}     2>/dev/null;
1901                 losetup -d /dev/loop${i} 2>/dev/null;
1902                 fi;
1903         done
1904         rm -rf $BASEDIR/build
1905         rm -rf $BASEDIR/cdrom
1906         rm -rf $BASEDIR/packages
1907         rm -rf $BASEDIR/log
1908         if [ -h "${TOOLS_DIR}" ]; then
1909                 rm -f "${TOOLS_DIR}"
1910         fi
1911         rm -f $BASEDIR/ipfire-*
1912         print_status DONE
1913         ;;
1914 docker)
1915         # Build the docker image if it does not exist, yet
1916         if ! docker images -a | grep -q ^ipfire-builder; then
1917                 if docker build -t ipfire-builder ${BASEDIR}/tools/docker; then
1918                         print_status DONE
1919                 else
1920                         print_status FAIL
1921                         exit 1
1922                 fi
1923         fi
1924
1925         # Run the container and enter a shell
1926         docker run -it --privileged -v "${BASEDIR}:/build" -w "/build" ipfire-builder bash -l
1927         ;;
1928 downloadsrc)
1929         if [ ! -d $BASEDIR/cache ]; then
1930                 mkdir $BASEDIR/cache
1931         fi
1932         mkdir -p $BASEDIR/log
1933         echo -e "${BOLD}Preload all source files${NORMAL}" | tee -a $LOGFILE
1934         FINISHED=0
1935         cd $BASEDIR/lfs
1936         for c in `seq $MAX_RETRIES`; do
1937                 if (( FINISHED==1 )); then
1938                         break
1939                 fi
1940                 FINISHED=1
1941                 cd $BASEDIR/lfs
1942                 for i in *; do
1943                         if [ -f "$i" -a "$i" != "Config" ]; then
1944                                 lfsmakecommoncheck ${i} || continue
1945
1946                                 make -s -f $i LFS_BASEDIR=$BASEDIR BUILD_ARCH="${BUILD_ARCH}" \
1947                                         MESSAGE="$i\t ($c/$MAX_RETRIES)" download >> $LOGFILE 2>&1
1948                                 if [ $? -ne 0 ]; then
1949                                         print_status FAIL
1950                                         FINISHED=0
1951                                 else
1952                                         if [ $c -eq 1 ]; then
1953                                         print_status DONE
1954                                         fi
1955                                 fi
1956                         fi
1957                 done
1958         done
1959         echo -e "${BOLD}***Verifying md5sums${NORMAL}"
1960         ERROR=0
1961         for i in *; do
1962                 if [ -f "$i" -a "$i" != "Config" ]; then
1963                         lfsmakecommoncheck ${i} > /dev/null || continue
1964                         make -s -f $i LFS_BASEDIR=$BASEDIR BUILD_ARCH="${BUILD_ARCH}" \
1965                                 MESSAGE="$i\t " md5 >> $LOGFILE 2>&1
1966                         if [ $? -ne 0 ]; then
1967                                 echo -ne "MD5 difference in lfs/$i"
1968                                 print_status FAIL
1969                                 ERROR=1
1970                         fi
1971                 fi
1972         done
1973         if [ $ERROR -eq 0 ]; then
1974                 echo -ne "${BOLD}all files md5sum match${NORMAL}"
1975                 print_status DONE
1976         else
1977                 echo -ne "${BOLD}not all files were correctly download${NORMAL}"
1978                 print_status FAIL
1979         fi
1980         cd - >/dev/null 2>&1
1981         ;;
1982 toolchain)
1983         # Clear screen
1984         ${INTERACTIVE} && clear
1985
1986         prepareenv
1987         print_build_stage "Toolchain compilation (${BUILD_ARCH})"
1988         buildtoolchain
1989         echo "`date -u '+%b %e %T'`: Create toolchain image for ${BUILD_ARCH}" | tee -a $LOGFILE
1990         test -d $BASEDIR/cache/toolchains || mkdir -p $BASEDIR/cache/toolchains
1991         cd $BASEDIR && tar -cf- --exclude='log/_build.*.log' build/${TOOLS_DIR} build/bin/sh log \
1992                 | zstd ${ZSTD_OPT} > cache/toolchains/$SNAME-$VERSION-toolchain-$TOOLCHAINVER-${BUILD_ARCH}.tar.zst
1993         md5sum cache/toolchains/$SNAME-$VERSION-toolchain-$TOOLCHAINVER-${BUILD_ARCH}.tar.zst \
1994                 > cache/toolchains/$SNAME-$VERSION-toolchain-$TOOLCHAINVER-${BUILD_ARCH}.md5
1995         stdumount
1996         ;;
1997 gettoolchain)
1998         # arbitrary name to be updated in case of new toolchain package upload
1999         PACKAGE=$SNAME-$VERSION-toolchain-$TOOLCHAINVER-${BUILD_ARCH}
2000         if [ ! -f $BASEDIR/cache/toolchains/$PACKAGE.tar.zst ]; then
2001                 URL_TOOLCHAIN=`grep URL_TOOLCHAIN lfs/Config | awk '{ print $3 }'`
2002                 test -d $BASEDIR/cache/toolchains || mkdir -p $BASEDIR/cache/toolchains
2003                 echo "`date -u '+%b %e %T'`: Load toolchain image for ${BUILD_ARCH}" | tee -a $LOGFILE
2004                 cd $BASEDIR/cache/toolchains
2005                 wget -U "IPFireSourceGrabber/2.x" $URL_TOOLCHAIN/$PACKAGE.tar.zst $URL_TOOLCHAIN/$PACKAGE.md5 >& /dev/null
2006                 if [ $? -ne 0 ]; then
2007                         echo "`date -u '+%b %e %T'`: error downloading $PACKAGE toolchain for ${BUILD_ARCH} machine" | tee -a $LOGFILE
2008                 else
2009                         if [ "`md5sum $PACKAGE.tar.zst | awk '{print $1}'`" = "`cat $PACKAGE.md5 | awk '{print $1}'`" ]; then
2010                                 echo "`date -u '+%b %e %T'`: toolchain md5 ok" | tee -a $LOGFILE
2011                         else
2012                                 exiterror "$PACKAGE.md5 did not match, check downloaded package"
2013                         fi
2014                 fi
2015         else
2016                 echo "Toolchain is already downloaded. Exiting..."
2017         fi
2018         ;;
2019 uploadsrc)
2020         if [ -z $IPFIRE_USER ]; then
2021                 echo -n "You have to setup IPFIRE_USER first. See .config for details."
2022                 print_status FAIL
2023                 exit 1
2024         fi
2025
2026         URL_SOURCE="$(awk '/^URL_SOURCE/ { print $3 }' lfs/Config)"
2027
2028         rsync \
2029                 --recursive \
2030                 --update \
2031                 --ignore-existing \
2032                 --progress \
2033                 --human-readable \
2034                 --exclude="toolchains/" \
2035                 "${BASEDIR}/cache/" \
2036                 "${IPFIRE_USER}@${URL_SOURCE}"
2037
2038         exit 0
2039         ;;
2040 lang)
2041         echo -ne "Checking the translations for missing or obsolete strings..."
2042         chmod 755 $BASEDIR/tools/{check_strings.pl,sort_strings.pl,check_langs.sh}
2043         $BASEDIR/tools/sort_strings.pl en
2044         $BASEDIR/tools/sort_strings.pl de
2045         $BASEDIR/tools/sort_strings.pl fr
2046         $BASEDIR/tools/sort_strings.pl es
2047         $BASEDIR/tools/sort_strings.pl pl
2048         $BASEDIR/tools/sort_strings.pl ru
2049         $BASEDIR/tools/sort_strings.pl nl
2050         $BASEDIR/tools/sort_strings.pl tr
2051         $BASEDIR/tools/sort_strings.pl it
2052         $BASEDIR/tools/check_strings.pl en > $BASEDIR/doc/language_issues.en
2053         $BASEDIR/tools/check_strings.pl de > $BASEDIR/doc/language_issues.de
2054         $BASEDIR/tools/check_strings.pl fr > $BASEDIR/doc/language_issues.fr
2055         $BASEDIR/tools/check_strings.pl es > $BASEDIR/doc/language_issues.es
2056         $BASEDIR/tools/check_strings.pl pl > $BASEDIR/doc/language_issues.pl
2057         $BASEDIR/tools/check_strings.pl ru > $BASEDIR/doc/language_issues.ru
2058         $BASEDIR/tools/check_strings.pl nl > $BASEDIR/doc/language_issues.nl
2059         $BASEDIR/tools/check_strings.pl tr > $BASEDIR/doc/language_issues.tr
2060         $BASEDIR/tools/check_strings.pl it > $BASEDIR/doc/language_issues.it
2061         $BASEDIR/tools/check_langs.sh > $BASEDIR/doc/language_missings
2062         print_status DONE
2063
2064         echo -ne "Updating language lists..."
2065         update_language_list ${BASEDIR}/src/installer/po
2066         update_language_list ${BASEDIR}/src/setup/po
2067         print_status DONE
2068         ;;
2069 update-contributors)
2070         update_contributors
2071         ;;
2072 find-dependencies)
2073         shift
2074         exec "${BASEDIR}/tools/find-dependencies" "${BASEDIR}/build" "$@"
2075         ;;
2076 check-manualpages)
2077         echo "Checking the manual pages for broken links..."
2078
2079         chmod 755 $BASEDIR/tools/check_manualpages.pl
2080         if $BASEDIR/tools/check_manualpages.pl; then
2081                 print_status DONE
2082         else
2083                 print_status FAIL
2084         fi
2085         ;;
2086 *)
2087         echo "Usage: $0 [OPTIONS] {build|changelog|clean|gettoolchain|downloadsrc|shell|sync|toolchain|update-contributors|find-dependencies|check-manualpages}"
2088         cat doc/make.sh-usage
2089         ;;
2090 esac