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