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