Raspi2-3_GenImage Commit - r70:94ac6dc790aa · Collaboration Tremplin des Sciences

code cleanup and even more spliting

Jan Wagner -

r70:94ac6dc790aa

parent child

Context file:

r70:94ac6dc790aa

Collapse all files

files/network/host.conf created 644 +1 0

	@@ -0,0 +1,1
				1	spoof warn

bootstrap.d/11-apt.sh +3 -3

             #
             # Setup APT repositories
             #
             # Load utility functions
             . ./functions.sh
             # Use proxy inside chroot
             if [ -z "$APT_PROXY" ] ; then
               install_readonly files/apt/10proxy $R/etc/apt/apt.conf.d/10proxy
-              sed -i -e "s/\"\"/\"${APT_PROXY}\"/" $R/etc/apt/apt.conf.d/10proxy
+              sed -i "s/\"\"/\"${APT_PROXY}\"/" $R/etc/apt/apt.conf.d/10proxy
             fi
             # Pin package flash-kernel to repositories.collabora.co.uk
             install_readonly files/apt/flash-kernel $R/etc/apt/preferences.d/flash-kernel
             # Upgrade collabora package index and install collabora keyring
             echo "deb https://repositories.collabora.co.uk/debian ${RELEASE} rpi2" >$R/etc/apt/sources.list
             chroot_exec apt-get -qq -y update
             chroot_exec apt-get -qq -y --force-yes install collabora-obs-archive-keyring
             # Set up initial sources.list
             install_readonly files/apt/sources.list $R/etc/apt/sources.list
-            sed -i -e "s/\/ftp.debian.org\//\/${APT_SERVER}\//" $R/etc/apt/sources.list
+            sed -i "s/\/ftp.debian.org\//\/${APT_SERVER}\//" $R/etc/apt/sources.list
-            sed -i -e "s/ jessie/ ${RELEASE}/" $R/etc/apt/sources.list
+            sed -i "s/ jessie/ ${RELEASE}/" $R/etc/apt/sources.list
             # Upgrade package index and update all installed packages and changed dependencies
             chroot_exec apt-get -qq -y update
             chroot_exec apt-get -qq -y -u dist-upgrade

bootstrap.d/12-locale.sh +9 -9

             #
             # Setup Locales and keyboard settings
             #
             # Load utility functions
             . ./functions.sh
             # Set up timezone
             echo ${TIMEZONE} >$R/etc/timezone
             chroot_exec dpkg-reconfigure -f noninteractive tzdata
             # Set up default locale and keyboard configuration
             if [ "$ENABLE_MINBASE" = false ] ; then
               # Set locale choice in debconf db, even though dpkg-reconfigure ignores and overwrites them due to some bug
               # https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=684134 https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=685957
               # ... so we have to set locales manually
               if [ "$DEFLOCAL" = "en_US.UTF-8" ] ; then
                 chroot_exec echo "locales locales/locales_to_be_generated multiselect ${DEFLOCAL} UTF-8" | debconf-set-selections
               else
                 # en_US.UTF-8 should be available anyway : https://www.debian.org/doc/manuals/debian-reference/ch08.en.html#_the_reconfiguration_of_the_locale
                 chroot_exec echo "locales locales/locales_to_be_generated multiselect en_US.UTF-8 UTF-8, ${DEFLOCAL} UTF-8" | debconf-set-selections
-                chroot_exec sed -i "/en_US.UTF-8/s/^#//" /etc/locale.gen
+                sed -i "/en_US.UTF-8/s/^#//" $R/etc/locale.gen
               fi
-              chroot_exec sed -i "/${DEFLOCAL}/s/^#//" /etc/locale.gen
+              sed -i "/${DEFLOCAL}/s/^#//" $R/etc/locale.gen
               chroot_exec echo "locales locales/default_environment_locale select ${DEFLOCAL}" | debconf-set-selections
               chroot_exec locale-gen
               chroot_exec update-locale LANG=${DEFLOCAL}
               # Keyboard configuration, if requested
               if [ "$XKB_MODEL" != "" ] ; then
-                chroot_exec sed -i "s/^XKBMODEL.*/XKBMODEL=\"${XKB_MODEL}\"/" /etc/default/keyboard
+                sed -i "s/^XKBMODEL.*/XKBMODEL=\"${XKB_MODEL}\"/" $R/etc/default/keyboard
               fi
               if [ "$XKB_LAYOUT" != "" ] ; then
-                chroot_exec sed -i "s/^XKBLAYOUT.*/XKBLAYOUT=\"${XKB_LAYOUT}\"/" /etc/default/keyboard
+                sed -i "s/^XKBLAYOUT.*/XKBLAYOUT=\"${XKB_LAYOUT}\"/" $R/etc/default/keyboard
               fi
               if [ "$XKB_VARIANT" != "" ] ; then
-                chroot_exec sed -i "s/^XKBVARIANT.*/XKBVARIANT=\"${XKB_VARIANT}\"/" /etc/default/keyboard
+                sed -i "s/^XKBVARIANT.*/XKBVARIANT=\"${XKB_VARIANT}\"/" $R/etc/default/keyboard
               fi
               if [ "$XKB_OPTIONS" != "" ] ; then
-                chroot_exec sed -i "s/^XKBOPTIONS.*/XKBOPTIONS=\"${XKB_OPTIONS}\"/" /etc/default/keyboard
+                sed -i "s/^XKBOPTIONS.*/XKBOPTIONS=\"${XKB_OPTIONS}\"/" $R/etc/default/keyboard
               fi
               chroot_exec dpkg-reconfigure -f noninteractive keyboard-configuration
               # Set up font console
               case "${DEFLOCAL}" in
                 *UTF-8)
-                  chroot_exec sed -i 's/^CHARMAP.*/CHARMAP="UTF-8"/' /etc/default/console-setup
+                  sed -i 's/^CHARMAP.*/CHARMAP="UTF-8"/' $R/etc/default/console-setup
                   ;;
                 *)
-                  chroot_exec sed -i 's/^CHARMAP.*/CHARMAP="guess"/' /etc/default/console-setup
+                  sed -i 's/^CHARMAP.*/CHARMAP="guess"/' $R/etc/default/console-setup
                   ;;
               esac
               chroot_exec dpkg-reconfigure -f noninteractive console-setup
-            else
+            else # ENABLE_MINBASE=true
               # Set POSIX default locales
               install_readonly files/locales/locale $R/etc/default/locale
             fi

bootstrap.d/13-kernel.sh +1 -1

             #
             # Build and Setup RPi2 Kernel
             #
             # Load utility functions
             . ./functions.sh
             # Fetch and build latest raspberry kernel
             if [ "$BUILD_KERNEL" = true ] ; then
               # Fetch current raspberrypi kernel sources
               git -C $R/usr/src clone --depth=1 https://github.com/raspberrypi/linux
               # Load default raspberry kernel configuration
               make -C $R/usr/src/linux ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- bcm2709_defconfig
               # Calculate optimal number of kernel building threads
               if [ "KERNEL_THREADS" = 1 ] ; then
                 if [ -f /proc/cpuinfo ] ; then
                   KERNEL_THREADS=$(grep -c processor /proc/cpuinfo)
                 fi
               fi
               # Cross compile kernel and modules
               make -C $R/usr/src/linux -j${KERNEL_THREADS} ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- zImage modules dtbs
               # Install kernel modules
               make -C $R/usr/src/linux ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- INSTALL_MOD_PATH=../../.. modules_install
               # Install kernel headers
               if [ "$KERNEL_HEADERS" = true ]; then
                 make -C $R/usr/src/linux ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- INSTALL_HDR_PATH=../.. headers_install
               fi
               # Copy and rename compiled kernel to boot directory
               mkdir $R/boot/firmware/
               $R/usr/src/linux/scripts/mkknlimg $R/usr/src/linux/arch/arm/boot/zImage $R/boot/firmware/kernel7.img
               # Copy dts and dtb device definitions
               mkdir $R/boot/firmware/overlays/
               cp $R/usr/src/linux/arch/arm/boot/dts/*.dtb $R/boot/firmware/
               cp $R/usr/src/linux/arch/arm/boot/dts/overlays/*.dtb* $R/boot/firmware/overlays/
               cp $R/usr/src/linux/arch/arm/boot/dts/overlays/README $R/boot/firmware/overlays/
               # Remove kernel sources
               if [ "$KERNEL_RMSRC" = true ]; then
                 rm -fr $R/usr/src/linux
               fi
               # Install raspberry bootloader and flash-kernel
               chroot_exec apt-get -qq -y --no-install-recommends install raspberrypi-bootloader-nokernel
-            else
+            else # BUILD_KERNEL=false
               # Kernel installation
               chroot_exec apt-get -qq -y --no-install-recommends install linux-image-${COLLABORA_KERNEL} raspberrypi-bootloader-nokernel
               # Install flash-kernel last so it doesn't try (and fail) to detect the platform in the chroot
               chroot_exec apt-get -qq -y install flash-kernel
               VMLINUZ="$(ls -1 $R/boot/vmlinuz-* | sort | tail -n 1)"
               [ -z "$VMLINUZ" ] && exit 1
               cp $VMLINUZ $R/boot/firmware/kernel7.img
             fi
             # Set up firmware boot cmdline
             if [ "$ENABLE_SPLITFS" = true ] ; then
               CMDLINE="dwc_otg.lpm_enable=0 root=/dev/sda1 rootfstype=ext4 rootflags=commit=100,data=writeback elevator=deadline rootwait net.ifnames=1 console=tty1 ${CMDLINE}"
             else
               CMDLINE="dwc_otg.lpm_enable=0 root=/dev/mmcblk0p2 rootfstype=ext4 rootflags=commit=100,data=writeback elevator=deadline rootwait net.ifnames=1 console=tty1 ${CMDLINE}"
             fi
             # Set up serial console support (if requested)
             if [ "$ENABLE_CONSOLE" = true ] ; then
               CMDLINE="${CMDLINE} console=ttyAMA0,115200 kgdboc=ttyAMA0,115200"
             fi
             # Set up IPv6 networking support
             if [ "$ENABLE_IPV6" = false ] ; then
               CMDLINE="${CMDLINE} ipv6.disable=1"
             fi
             echo "${CMDLINE}" >$R/boot/firmware/cmdline.txt
             # Set up firmware config
             install_readonly files/boot/config.txt $R/boot/firmware/config.txt
             # Load snd_bcm2835 kernel module at boot time
             if [ "$ENABLE_SOUND" = true ] ; then
               echo "snd_bcm2835" >>$R/etc/modules
             fi
             # Set smallest possible GPU memory allocation size: 16MB (no X)
             if [ "$ENABLE_MINGPU" = true ] ; then
               echo "gpu_mem=16" >>$R/boot/firmware/config.txt
             fi
             # Create symlinks
             ln -sf firmware/config.txt $R/boot/config.txt
             ln -sf firmware/cmdline.txt $R/boot/cmdline.txt
             # Prepare modules-load.d directory
             mkdir -p $R/lib/modules-load.d/
             # Load random module on boot
             if [ "$ENABLE_HWRANDOM" = true ] ; then
               cat <<EOM >$R/lib/modules-load.d/rpi2.conf
             bcm2708_rng
             EOM
             fi
             # Prepare modprobe.d directory
             mkdir -p $R/etc/modprobe.d/
             # Blacklist sound modules
             install_readonly files/modprobe.d/raspi-blacklist.conf $R/etc/modprobe.d/raspi-blacklist.conf
             # Create default fstab
             install_readonly files/mount/fstab $R/etc/fstab
             if [ "$ENABLE_SPLITFS" = true ] ; then
               sed -i 's/mmcblk0p2/sda1/' $R/etc/fstab
             fi
             # Avoid swapping and increase cache sizes
             install_readonly files/sysctl.d/81-rpi-vm.conf $R/etc/sysctl.d/81-rpi-vm.conf

bootstrap.d/20-networking.sh +8 -9

             #
             # Setup Networking
             #
             # Load utility functions
             . ./functions.sh
             # Set up IPv4 hosts
             install_readonly files/network/hostname $R/etc/hostname
-            sed -i -e "s/^rpi2-jessie/${HOSTNAME}/" $R/etc/hostname
+            sed -i "s/^rpi2-jessie/${HOSTNAME}/" $R/etc/hostname
             install_readonly files/network/hosts $R/etc/hosts
-            sed -i -e "s/rpi2-jessie/${HOSTNAME}/" $R/etc/hosts
+            sed -i "s/rpi2-jessie/${HOSTNAME}/" $R/etc/hosts
             if [ "$NET_ADDRESS" != "" ] ; then
               NET_IP=$(echo ${NET_ADDRESS} | cut -f 1 -d'/')
               sed -i "s/^127.0.1.1/${NET_IP}/" $R/etc/hosts
             fi
             # Set up IPv6 hosts
             if [ "$ENABLE_IPV6" = true ] ; then
               cat <<EOM >>$R/etc/hosts
             ::1             localhost ip6-localhost ip6-loopback
             ff02::1         ip6-allnodes
             ff02::2         ip6-allrouters
             EOM
             fi
             # Place hint about network configuration
             install_readonly files/network/interfaces $R/etc/network/interfaces
             if [ "$ENABLE_DHCP" = true ] ; then
-            # Enable systemd-networkd DHCP configuration for interface eth0
+              # Enable systemd-networkd DHCP configuration for interface eth0
-            install_readonly files/network/eth.network $R/etc/systemd/network/eth.network
+              install_readonly files/network/eth.network $R/etc/systemd/network/eth.network
-            # Set DHCP configuration to IPv4 only
+              # Set DHCP configuration to IPv4 only
               if [ "$ENABLE_IPV6" = false ] ; then
                 sed -i "s/^DHCP=yes/DHCP=v4/" $R/etc/systemd/network/eth.network
               fi
             else # ENABLE_DHCP=false
               cat <<EOM >$R/etc/systemd/network/eth.network
             [Match]
             Name=eth0
             [Network]
             DHCP=no
             Address=${NET_ADDRESS}
             Gateway=${NET_GATEWAY}
             DNS=${NET_DNS_1}
             DNS=${NET_DNS_2}
             Domains=${NET_DNS_DOMAINS}
             NTP=${NET_NTP_1}
             NTP=${NET_NTP_2}
             EOM
             fi
             # Enable systemd-networkd service
             chroot_exec systemctl enable systemd-networkd
             # Enable network stack hardening
             if [ "$ENABLE_HARDNET" = true ] ; then
               install_readonly files/sysctl.d/82-rpi-net-hardening.conf $R/etc/sysctl.d/82-rpi-net-hardening.conf
-            # Enable resolver warnings about spoofed addresses
+              # Enable resolver warnings about spoofed addresses
-              cat <<EOM >>$R/etc/host.conf
+              install_readonly files/network/host.conf $R/etc/host.conf
-            spoof warn
-            EOM
             fi

bootstrap.d/21-firewall.sh +3 -3

             #
             # Setup Firewall
             #
             # Load utility functions
             . ./functions.sh
             if [ "$ENABLE_IPTABLES" = true ] ; then
               # Create iptables configuration directory
               mkdir -p "$R/etc/iptables"
               # Create iptables systemd service
               install_readonly files/iptables/iptables.service $R/etc/systemd/system/iptables.service
               # Create flush-table script called by iptables service
               install_exec files/iptables/flush-iptables.sh $R/etc/iptables/flush-iptables.sh
               # Create iptables rule file
               install_readonly files/iptables/iptables.rules $R/etc/iptables/iptables.rules
               # Reload systemd configuration and enable iptables service
               chroot_exec systemctl daemon-reload
               chroot_exec systemctl enable iptables.service
               if [ "$ENABLE_IPV6" = true ] ; then
                 # Create ip6tables systemd service
                 install_readonly files/iptables/ip6tables.service $R/etc/systemd/system/ip6tables.service
                 # Create ip6tables file
                 install_exec files/iptables/flush-ip6tables.sh $R/etc/iptables/flush-ip6tables.sh
                 install_readonly files/iptables/ip6tables.rules $R/etc/iptables/ip6tables.rules
                 # Reload systemd configuration and enable iptables service
                 chroot_exec systemctl daemon-reload
                 chroot_exec systemctl enable ip6tables.service
               fi
             fi
-            # Remove SSHD related iptables rules
             if [ "$ENABLE_SSHD" = false ] ; then
-             sed -e '/^#/! {/SSH/ s/^/# /}' -i $R/etc/iptables/iptables.rules 2> /dev/null
+             # Remove SSHD related iptables rules
-             sed -e '/^#/! {/SSH/ s/^/# /}' -i $R/etc/iptables/ip6tables.rules 2> /dev/null
+             sed -i "/^#/! {/SSH/ s/^/# /}" $R/etc/iptables/iptables.rules 2> /dev/null
+             sed -i "/^#/! {/SSH/ s/^/# /}" $R/etc/iptables/ip6tables.rules 2> /dev/null
             fi

bootstrap.d/30-security.sh +2 -1

             #
             # Setup users and security settings
             #
             # Load utility functions
             . ./functions.sh
             # Generate crypt(3) password string
             ENCRYPTED_PASSWORD=`mkpasswd -m sha-512 ${PASSWORD}`
             # Set up default user
             if [ "$ENABLE_USER" = true ] ; then
               chroot_exec adduser --gecos pi --add_extra_groups --disabled-password pi
               chroot_exec usermod -a -G sudo -p "${ENCRYPTED_PASSWORD}" pi
             fi
             # Set up root password or not
             if [ "$ENABLE_ROOT" = true ]; then
               chroot_exec usermod -p "${ENCRYPTED_PASSWORD}" root
               if [ "$ENABLE_ROOT_SSH" = true ]; then
-                sed -i 's|[#]*PermitRootLogin.*|PermitRootLogin yes|g' $R/etc/ssh/sshd_config
+                sed -i "s|[#]*PermitRootLogin.*|PermitRootLogin yes|g" $R/etc/ssh/sshd_config
               fi
             else
+              # Set no root password to disable root login
               chroot_exec usermod -p \'!\' root
             fi
             # Enable serial console systemd style
             if [ "$ENABLE_CONSOLE" = true ] ; then
               chroot_exec systemctl enable serial-getty\@ttyAMA0.service
             fi

bootstrap.d/31-logging.sh +1 -1

             #
             # Setup Logging
             #
             # Load utility functions
             . ./functions.sh
             # Disable rsyslog
             if [ "$ENABLE_RSYSLOG" = false ]; then
-              sed -i 's|[#]*ForwardToSyslog=yes|ForwardToSyslog=no|g' $R/etc/systemd/journald.conf
+              sed -i "s|[#]*ForwardToSyslog=yes|ForwardToSyslog=no|g" $R/etc/systemd/journald.conf
               chroot_exec systemctl disable rsyslog
               chroot_exec apt-get purge -q -y --force-yes rsyslog
             fi

rpi2-gen-image.sh +1 0

             #!/bin/sh
             ########################################################################
             # rpi2-gen-image.sh					   ver2a 12/2015
             #
             # Advanced debian "jessie" bootstrap script for RPi2
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # some parts based on rpi2-build-image:
             # Copyright (C) 2015 Ryan Finnie <ryan@finnie.org>
             # Copyright (C) 2015 Luca Falavigna <dktrkranz@debian.org>
             ########################################################################
             # Load utility functions
             . ./functions.sh
+            # Introduce settings
             set -e
             echo -n -e "\n#\n# RPi2 Bootstrap Settings\n#\n"
             set -x
             # Debian release
             RELEASE=${RELEASE:=jessie}
             COLLABORA_KERNEL=${COLLABORA_KERNEL:=3.18.0-trunk-rpi2}
             # Build settings
             BASEDIR=$(pwd)/images/${RELEASE}
             BUILDDIR=${BASEDIR}/build
             # General settings
             HOSTNAME=${HOSTNAME:=rpi2-${RELEASE}}
             PASSWORD=${PASSWORD:=raspberry}
             DEFLOCAL=${DEFLOCAL:="en_US.UTF-8"}
             TIMEZONE=${TIMEZONE:="Europe/Berlin"}
             EXPANDROOT=${EXPANDROOT:=true}
             # Keyboard settings
             XKB_MODEL=${XKB_MODEL:=""}
             XKB_LAYOUT=${XKB_LAYOUT:=""}
             XKB_VARIANT=${XKB_VARIANT:=""}
             XKB_OPTIONS=${XKB_OPTIONS:=""}
             # Network settings (DHCP)
             ENABLE_DHCP=${ENABLE_DHCP:=true}
             # Network settings (static)
             # only used on ENABLE_DHCP=false
             NET_ADDRESS=${NET_ADDRESS:=""}
             NET_GATEWAY=${NET_GATEWAY:=""}
             NET_DNS_1=${NET_DNS_1:=""}
             NET_DNS_2=${NET_DNS_2:=""}
             NET_DNS_DOMAINS=${NET_DNS_DOMAINS:=""}
             NET_NTP_1=${NET_NTP_1:=""}
             NET_NTP_2=${NET_NTP_2:=""}
             # APT settings
             APT_PROXY=${APT_PROXY:=""}
             APT_SERVER=${APT_SERVER:="ftp.debian.org"}
             # Feature settings
             ENABLE_CONSOLE=${ENABLE_CONSOLE:=true}
             ENABLE_IPV6=${ENABLE_IPV6:=true}
             ENABLE_SSHD=${ENABLE_SSHD:=true}
             ENABLE_SOUND=${ENABLE_SOUND:=true}
             ENABLE_DBUS=${ENABLE_DBUS:=true}
             ENABLE_HWRANDOM=${ENABLE_HWRANDOM:=true}
             ENABLE_MINGPU=${ENABLE_MINGPU:=false}
             ENABLE_XORG=${ENABLE_XORG:=false}
             ENABLE_WM=${ENABLE_WM:=""}
             ENABLE_RSYSLOG=${ENABLE_RSYSLOG:=true}
             ENABLE_USER=${ENABLE_USER:=true}
             ENABLE_ROOT=${ENABLE_ROOT:=false}
             ENABLE_ROOT_SSH=${ENABLE_ROOT_SSH:=false}
             # Advanced settings
             ENABLE_MINBASE=${ENABLE_MINBASE:=false}
             ENABLE_UBOOT=${ENABLE_UBOOT:=false}
             ENABLE_FBTURBO=${ENABLE_FBTURBO:=false}
             ENABLE_HARDNET=${ENABLE_HARDNET:=false}
             ENABLE_IPTABLES=${ENABLE_IPTABLES:=false}
             ENABLE_SPLITFS=${ENABLE_SPLITFS:=false}
             # Kernel compilation settings
             BUILD_KERNEL=${BUILD_KERNEL:=false}
             KERNEL_THREADS=${KERNEL_THREADS:=1}
             KERNEL_HEADERS=${KERNEL_HEADERS:=true}
             KERNEL_RMSRC=${KERNEL_RMSRC:=true}
             # Image chroot path
             R=${BUILDDIR}/chroot
             CHROOT_SCRIPTS=${CHROOT_SCRIPTS:=""}
             # Packages required for bootstrapping
             REQUIRED_PACKAGES="debootstrap debian-archive-keyring qemu-user-static binfmt-support dosfstools rsync bmap-tools whois git-core"
             # Missing packages that need to be installed
             MISSING_PACKAGES=""
             # Packages required in the chroot build environment
             APT_INCLUDES=${APT_INCLUDES:=""}
             APT_INCLUDES="${APT_INCLUDES},apt-transport-https,ca-certificates,debian-archive-keyring,dialog,sudo"
             set +x
             # Are we running as root?
             if [ "$(id -u)" -ne "0" ] ; then
               echo "this script must be executed with root privileges"
               exit 1
             fi
             # Add packages required for kernel cross compilation
             if [ "$BUILD_KERNEL" = true ] ; then
               REQUIRED_PACKAGES="${REQUIRED_PACKAGES} crossbuild-essential-armhf"
             fi
             # Check if all required packages are installed
             for package in $REQUIRED_PACKAGES ; do
               if [ "`dpkg-query -W -f='${Status}' $package`" != "install ok installed" ] ; then
                 MISSING_PACKAGES="$MISSING_PACKAGES $package"
               fi
             done
             # Ask if missing packages should get installed right now
             if [ -n "$MISSING_PACKAGES" ] ; then
               echo "the following packages needed by this script are not installed:"
               echo "$MISSING_PACKAGES"
               echo -n "\ndo you want to install the missing packages right now? [y/n] "
               read confirm
               if [ "$confirm" != "y" ] ; then
                 exit 1
               fi
             fi
             # Make sure all required packages are installed
             apt-get -qq -y install ${REQUIRED_PACKAGES}
             # Don't clobber an old build
             if [ -e "$BUILDDIR" ]; then
               echo "directory $BUILDDIR already exists, not proceeding"
               exit 1
             fi
             set -x
             # Call "cleanup" function on various signals and errors
             trap cleanup 0 1 2 3 6
             # Set up chroot directory
             mkdir -p $R
             # Add required packages for the minbase installation
             if [ "$ENABLE_MINBASE" = true ] ; then
               APT_INCLUDES="${APT_INCLUDES},vim-tiny,netbase,net-tools"
             else
               APT_INCLUDES="${APT_INCLUDES},locales,keyboard-configuration,console-setup"
             fi
             # Add parted package, required to get partprobe utility
             if [ "$EXPANDROOT" = true ] ; then
               APT_INCLUDES="${APT_INCLUDES},parted"
             fi
             # Add dbus package, recommended if using systemd
             if [ "$ENABLE_DBUS" = true ] ; then
               APT_INCLUDES="${APT_INCLUDES},dbus"
             fi
             # Add iptables IPv4/IPv6 package
             if [ "$ENABLE_IPTABLES" = true ] ; then
               APT_INCLUDES="${APT_INCLUDES},iptables"
             fi
             # Add openssh server package
             if [ "$ENABLE_SSHD" = true ] ; then
               APT_INCLUDES="${APT_INCLUDES},openssh-server"
             fi
             # Add alsa-utils package
             if [ "$ENABLE_SOUND" = true ] ; then
               APT_INCLUDES="${APT_INCLUDES},alsa-utils"
             fi
             # Add rng-tools package
             if [ "$ENABLE_HWRANDOM" = true ] ; then
               APT_INCLUDES="${APT_INCLUDES},rng-tools"
             fi
             if [ "$ENABLE_USER" = true ]; then
               APT_INCLUDES="${APT_INCLUDES},sudo"
             fi
             # Add fbturbo video driver
             if [ "$ENABLE_FBTURBO" = true ] ; then
               # Enable xorg package dependencies
               ENABLE_XORG=true
             fi
             # Add user defined window manager package
             if [ -n "$ENABLE_WM" ] ; then
               APT_INCLUDES="${APT_INCLUDES},${ENABLE_WM}"
               # Enable xorg package dependencies
               ENABLE_XORG=true
             fi
             # Add xorg package
             if [ "$ENABLE_XORG" = true ] ; then
               APT_INCLUDES="${APT_INCLUDES},xorg"
             fi
             ## Main bootstrap
             for i in bootstrap.d/*.sh; do
               head -n 3 $i
               . $i
             done
             ## Custom bootstrap scripts
             if [ -d "custom.d" ]; then
               for i in custom.d/*.sh; do
                 . $i
               done
             fi
             # Invoke custom scripts
             if [ -n "${CHROOT_SCRIPTS}" ]; then
               cp -r "${CHROOT_SCRIPTS}" "${R}/chroot_scripts"
               LANG=C chroot $R bash -c 'for SCRIPT in /chroot_scripts/*; do if [ -f $SCRIPT -a -x $SCRIPT ]; then $SCRIPT; fi done;'
               rm -rf "${R}/chroot_scripts"
             fi
             ## Cleanup
             chroot_exec apt-get -y clean
             chroot_exec apt-get -y autoclean
             chroot_exec apt-get -y autoremove
             # Unmount mounted filesystems
             umount -l $R/proc
             umount -l $R/sys
             # Clean up files
             rm -f $R/etc/apt/sources.list.save
             rm -f $R/etc/resolvconf/resolv.conf.d/original
             rm -rf $R/run
             mkdir -p $R/run
             rm -f $R/etc/*-
             rm -f $R/root/.bash_history
             rm -rf $R/tmp/*
             rm -f $R/var/lib/urandom/random-seed
             [ -L $R/var/lib/dbus/machine-id ] || rm -f $R/var/lib/dbus/machine-id
             rm -f $R/etc/machine-id
             rm -fr $R/etc/apt/apt.conf.d/10proxy
             rm -f $R/etc/resolv.conf
             # Calculate size of the chroot directory in KB
             CHROOT_SIZE=$(expr `du -s $R | awk '{ print $1 }'`)
             # Calculate the amount of needed 512 Byte sectors
             TABLE_SECTORS=$(expr 1 \* 1024 \* 1024 \/ 512)
             FRMW_SECTORS=$(expr 64 \* 1024 \* 1024 \/ 512)
             ROOT_OFFSET=$(expr ${TABLE_SECTORS} + ${FRMW_SECTORS})
             # The root partition is EXT4
             # This means more space than the actual used space of the chroot is used.
             # As overhead for journaling and reserved blocks 20% are added.
             ROOT_SECTORS=$(expr $(expr ${CHROOT_SIZE} + ${CHROOT_SIZE} \/ 100 \* 20) \* 1024 \/ 512)
             # Calculate required image size in 512 Byte sectors
             IMAGE_SECTORS=$(expr ${TABLE_SECTORS} + ${FRMW_SECTORS} + ${ROOT_SECTORS})
             # Prepare date string for image file name
             DATE="$(date +%Y-%m-%d)"
             # Prepare image file
             if [ "$ENABLE_SPLITFS" = true ] ; then
               dd if=/dev/zero of="$BASEDIR/${DATE}-debian-${RELEASE}-frmw.img" bs=512 count=${TABLE_SECTORS}
               dd if=/dev/zero of="$BASEDIR/${DATE}-debian-${RELEASE}-frmw.img" bs=512 count=0 seek=${FRMW_SECTORS}
               dd if=/dev/zero of="$BASEDIR/${DATE}-debian-${RELEASE}-root.img" bs=512 count=${TABLE_SECTORS}
               dd if=/dev/zero of="$BASEDIR/${DATE}-debian-${RELEASE}-root.img" bs=512 count=0 seek=${ROOT_SECTORS}
               # Write partition tables
               sfdisk -q -L -f "$BASEDIR/${DATE}-debian-${RELEASE}-frmw.img" <<EOM
             unit: sectors
 : start=   ${TABLE_SECTORS}, size=   ${FRMW_SECTORS}, Id= c, bootable
 : start=                  0, size=                 0, Id= 0
 : start=                  0, size=                 0, Id= 0
 : start=                  0, size=                 0, Id= 0
             EOM
               sfdisk -q -L -f "$BASEDIR/${DATE}-debian-${RELEASE}-root.img" <<EOM
             unit: sectors
 : start=   ${TABLE_SECTORS}, size=   ${ROOT_SECTORS}, Id=83
 : start=                  0, size=                 0, Id= 0
 : start=                  0, size=                 0, Id= 0
 : start=                  0, size=                 0, Id= 0
             EOM
               # Set up temporary loop devices
               FRMW_LOOP="$(losetup -o 1M --sizelimit 64M -f --show $BASEDIR/${DATE}-debian-${RELEASE}-frmw.img)"
               ROOT_LOOP="$(losetup -o 1M -f --show $BASEDIR/${DATE}-debian-${RELEASE}-root.img)"
             else
               dd if=/dev/zero of="$BASEDIR/${DATE}-debian-${RELEASE}.img" bs=512 count=${TABLE_SECTORS}
               dd if=/dev/zero of="$BASEDIR/${DATE}-debian-${RELEASE}.img" bs=512 count=0 seek=${IMAGE_SECTORS}
               # Write partition table
               sfdisk -q -f "$BASEDIR/${DATE}-debian-${RELEASE}.img" <<EOM
             unit: sectors
 : start=   ${TABLE_SECTORS}, size=   ${FRMW_SECTORS}, Id= c, bootable
 : start=     ${ROOT_OFFSET}, size=   ${ROOT_SECTORS}, Id=83
 : start=                  0, size=                 0, Id= 0
 : start=                  0, size=                 0, Id= 0
             EOM
               # Set up temporary loop devices
               FRMW_LOOP="$(losetup -o 1M --sizelimit 64M -f --show $BASEDIR/${DATE}-debian-${RELEASE}.img)"
               ROOT_LOOP="$(losetup -o 65M -f --show $BASEDIR/${DATE}-debian-${RELEASE}.img)"
             fi
             # Build filesystems
             mkfs.vfat "$FRMW_LOOP"
             mkfs.ext4 "$ROOT_LOOP"
             # Mount the temporary loop devices
             mkdir -p "$BUILDDIR/mount"
             mount "$ROOT_LOOP" "$BUILDDIR/mount"
             mkdir -p "$BUILDDIR/mount/boot/firmware"
             mount "$FRMW_LOOP" "$BUILDDIR/mount/boot/firmware"
             # Copy all files from the chroot to the loop device mount point directory
             rsync -a "$R/" "$BUILDDIR/mount/"
             # Unmount all temporary loop devices and mount points
             cleanup
             # Create block map file(s) of image(s)
             if [ "$ENABLE_SPLITFS" = true ] ; then
               # Create block map files for "bmaptool"
               bmaptool create -o "$BASEDIR/${DATE}-debian-${RELEASE}-frmw.bmap" "$BASEDIR/${DATE}-debian-${RELEASE}-frmw.img"
               bmaptool create -o "$BASEDIR/${DATE}-debian-${RELEASE}-root.bmap" "$BASEDIR/${DATE}-debian-${RELEASE}-root.img"
               # Image was successfully created
               echo "$BASEDIR/${DATE}-debian-${RELEASE}-frmw.img ($(expr ${TABLE_SECTORS} + ${FRMW_SECTORS} \* 512 \/ 1024 \/ 1024)M)" ": successfully created"
               echo "$BASEDIR/${DATE}-debian-${RELEASE}-root.img ($(expr ${TABLE_SECTORS} + ${ROOT_SECTORS} \* 512 \/ 1024 \/ 1024)M)" ": successfully created"
             else
               # Create block map file for "bmaptool"
               bmaptool create -o "$BASEDIR/${DATE}-debian-${RELEASE}.bmap" "$BASEDIR/${DATE}-debian-${RELEASE}.img"
               # Image was successfully created
               echo "$BASEDIR/${DATE}-debian-${RELEASE}.img ($(expr ${TABLE_SECTORS} + ${FRMW_SECTORS} + ${ROOT_SECTORS} \* 512 \/ 1024 \/ 1024)M)" ": successfully created"
             fi

General Comments 0

Écrire
Preview

Vous devez vous connecter pour laisser un commentaire. Se connecter maintenant

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Dépôts
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages