blackarch-install

#!/bin/sh
################################################################################
#                                                                              #
# blackarch-installer - Official Installer for BlackArch Linux                 #
#                                                                              #
# AUTHOR                                                                       #
# noptrix@nullsecurity.net                                                     #
#                                                                              #
################################################################################


# blackarch-installer version
VERSION="v0.7.4"

# path to blackarch-installer
BI_PATH="/usr/share/blackarch-installer"

# true / false
TRUE=0
FALSE=1

# return codes
SUCCESS=0
FAILURE=1

# verbose mode - default: quiet
VERBOSE="/dev/null"

# colors
WHITE="$(tput setaf 7)"
WHITEB="$(tput bold ; tput setaf 7)"
GREEN="$(tput setaf 2)"
GREENB="$(tput bold ; tput setaf 2)"
RED="$(tput setaf 1)"
REDB="$(tput bold; tput setaf 1)"
YELLOW="$(tput setaf 3)"
YELLOWB="$(tput bold ; tput setaf 3)"
BLINK="$(tput blink)"
NC="$(tput sgr0)"

# installation mode
INSTALL_MODE=""

# install modes
INSTALL_REPO="1"
INSTALL_LIVE_ISO="2"
INSTALL_BLACKMAN="3"

# chosen keymap
KEYMAP=""

# set keymap
SET_KEYMAP="1"

# list keymaps
LIST_KEYMAP="2"

# network interfaces
NET_IFS=""

# chosen network interface
NET_IF=""

# network configuration mode
NET_CONF_MODE=""

# network configuration modes
NET_CONF_AUTO="1"
NET_CONF_WLAN="2"
NET_CONF_MANUAL="3"
NET_CONF_SKIP="4"

# hostname
HOST_NAME=""

# host ipv4 address
HOST_IPV4=""

# gateway ipv4 address
GATEWAY=""

# subnet mask
SUBNETMASK=""

# broadcast address
BROADCAST=""

# nameserver address
NAMESERVER=""

# LUKS flag
LUKS=""

# avalable hard drive
HD_DEVS=""

# chosen hard drive device
HD_DEV=""

# partition label: gpt or msdos
PART_LABEL=""

# boot partition
BOOT_PART=""

# root partition
ROOT_PART=""

# crypted root
CRYPT_ROOT="r00t"

# swap partition
SWAP_PART=""

# boot fs type - default: ext4
BOOT_FS_TYPE=""

# root fs type - default: ext4
ROOT_FS_TYPE=""

# chroot directory / blackarch linux installation
CHROOT="/mnt"

# normal system user
NORMAL_USER=""

# default BlackArch Linux repository URL
BA_REPO_URL='https://www.mirrorservice.org/sites/blackarch.org/blackarch/$repo/os/$arch'

# default ArchLinux repository URL
AR_REPO_URL="https://archlinux.surlyjake.com/archlinux/\$repo/os/\$arch"
AR_REPO_URL="${AR_REPO_URL} http://mirrors.evowise.com/archlinux/\$repo/os/\$arch"
AR_REPO_URL="${AR_REPO_URL} http://mirror.rackspace.com/archlinux/\$repo/os/\$arch"

# X (display + window managers ) setup - default: false
X_SETUP=$FALSE

# VirtualBox setup - default: false
VBOX_SETUP=$FALSE

# VMware setup - default: false
VMWARE_SETUP=$FALSE

# BlackArch Linux tools setup - default: false
BA_TOOLS_SETUP=$FALSE

# wlan ssid
WLAN_SSID=""

# wlan passphrase
WLAN_PASSPHRASE=""

# check type of ISO (live? netinst?)
ISO_TYPE=""


# check exit status
check()
{
  es=$1
  func="$2"
  info="$3"

  if [ $es -ne 0 ]
  then
    echo
    warn "Something went wrong with ${func}. ${info}."
    sleep 5
  fi
}


# print formatted output
wprintf()
{
  fmt="${1}"

  shift
  printf "%s${fmt}%s" "${WHITE}" "${@}" "${NC}"

  return $SUCCESS
}


# print warning
warn()
{
  printf "%s[!] WARNING: %s%s\n" "${YELLOW}" "${@}" "${NC}"

  return $SUCCESS
}


# print error and exit
err()
{
  printf "%s[-] ERROR: %s%s\n" "${RED}" "${@}" "${NC}"

  exit $FAILURE

  return $SUCCESS
}


# leet banner (very important)
banner()
{
  columns="$(tput cols)"
  str="--==[ blackarch-installer ${VERSION} ]==--"

  printf "${REDB}%*s${NC}\n" "${COLUMNS:-$(tput cols)}" | tr ' ' '-'

  echo "${str}" |
  while IFS= read -r line
  do
    printf "%s%*s\n%s" "${WHITEB}" $(( (${#line} + columns) / 2)) \
      "$line" "${NC}"
  done

  printf "${REDB}%*s${NC}\n\n\n" "${COLUMNS:-$(tput cols)}" | tr ' ' '-'

  return $SUCCESS
}


# check type of iso
check_iso_type()
{
  if [ "$(which dnsspider 2> /dev/null)" ]
  then
    ISO_TYPE="live"
  else
    ISO_TYPE="net"
  fi

  return $SUCCESS
}


# sleep and clear
sleep_clear()
{
  sleep $1
  clear

  return $SUCCESS
}


# confirm user inputted yYnN
confirm()
{
  header="${1}"
  ask="${2}"

  while true
  do
    title "${header}"
    wprintf "${ask}"
    read input
    case $input in
      y|Y|yes|YES|Yes) return $TRUE ;;
      n|N|no|NO|No) return $FALSE ;;
      *) clear ; continue ;;
    esac
  done

  return $SUCCESS
}


# print menu title
title()
{
  banner
  printf "${GREEN}>> %s${NC}\n\n\n" "${@}"

  return "${SUCCESS}"
}


# check for environment issues
check_env()
{
  if [ -f "/var/lib/pacman/db.lck" ]
  then
    err "pacman locked - Please remove /var/lib/pacman/db.lck"
  fi
}


# check user id
check_uid()
{
  if [ "$(id -u)" -ne 0 ]
  then
    err "You must be root to run the BlackArch installer!"
  fi

  return $SUCCESS
}


# welcome and ask for installation mode
ask_install_mode()
{
  while [ \
    "${INSTALL_MODE}" != "${INSTALL_REPO}" -a \
    "${INSTALL_MODE}" != "${INSTALL_BLACKMAN}" -a \
    "${INSTALL_MODE}" != "${INSTALL_LIVE_ISO}" ]
  do
    title "Welcome to the BlackArch Linux installer!"
    wprintf "[+] Available installation modes:"
    printf "\n
  1. Install from BlackArch repository (online)
  2. Install from BlackArch Live-ISO (offline)
  3. Install from sources using blackman (online)\n\n"
    wprintf "[?] Choose an installation mode: "
    read INSTALL_MODE
    if [ "${INSTALL_MODE}" = "${INSTALL_LIVE_ISO}" ]
    then
      if [ "${ISO_TYPE}" = "net" ]
      then
        err "WTF, Live-ISO mode with Netinstall? Nope, sorry!"
      fi
    fi
  clear
  done

  return $SUCCESS
}


# ask for keymap to use
ask_keymap()
{
  while [ \
    "${keymap_opt}" != "${SET_KEYMAP}" -a \
    "${keymap_opt}" != "${LIST_KEYMAP}" ]
  do
    title "Keymap Setup"
    wprintf "[+] Available keymap options:"
    printf "\n
  1. Set a keymap
  2. List available keymaps\n\n"
    wprintf "[?] Make a choice: "
    read keymap_opt

    if [ "${keymap_opt}" = "${SET_KEYMAP}" ]
    then
      break
    elif [ "${keymap_opt}" = "${LIST_KEYMAP}" ]
    then
      localectl list-keymaps
      echo
    else
      clear
      continue
    fi
    clear
  done

  clear

  return $SUCCESS
}


# set keymap to use
set_keymap()
{
  title "Keymap Setup"
  wprintf "[?] Set keymap [us]: "
  read KEYMAP

  # default keymap
  if [ -z "${KEYMAP}" ]
  then
    echo
    warn "Setting default keymap: US"
    sleep 1
    KEYMAP="us"
  fi

  localectl set-keymap --no-convert "${KEYMAP}"
  loadkeys "${KEYMAP}" > ${VERBOSE} 2>&1
  check $? "setting keymap" "Choosing default for you: US"
  localectl set-keymap --no-conver "us"
  loadkeys "us"

  return $SUCCESS
}


# enable multilib in pacman.conf if x86_64 present
enable_pacman_multilib()
{
  path="${1}"

  if [ "${path}" = "chroot" ]
  then
    path="${CHROOT}"
  else
    path=""
  fi

  title "Pacman Setup"

  if [ "$(uname -m)" = "x86_64" ]
  then
    wprintf "[+] Enabling multilib support"
    printf "\n\n"
    if grep -q "#\[multilib\]" ${path}/etc/pacman.conf
    then
      # it exists but commented
      sed -i '/\[multilib\]/{ s/^#//; n; s/^#//; }' ${path}/etc/pacman.conf
    elif ! grep -q "\[multilib\]" ${path}/etc/pacman.conf
    then
      # it does not exist at all
      printf "[multilib]\nInclude = /etc/pacman.d/mirrorlist\n" \
        >> ${path}/etc/pacman.conf
    fi
  fi

  return $SUCCESS
}


# enable color mode in pacman.conf
enable_pacman_color()
{
  path="${1}"

  if [ "${path}" = "chroot" ]
  then
    path="${CHROOT}"
  else
    path=""
  fi

  title "Pacman Setup"

  wprintf "[+] Enabling color mode"
  printf "\n\n"

  sed -i 's/^#Color/Color/' ${path}/etc/pacman.conf

  return $SUCCESS
}


# update pacman package database
update_pkg_database()
{
  title "Pacman Setup"

  wprintf "[+] Updating pacman database"
  printf "\n\n"

  pacman -Syy --noconfirm

  return $SUCCESS
}


# update pacman.conf and database
update_pacman()
{
  enable_pacman_multilib
  sleep_clear 1

  enable_pacman_color
  sleep_clear 1

  update_pkg_database
  sleep_clear 1

  return $SUCCESS
}


# ask user for hostname
ask_hostname()
{
  while [ -z "${HOST_NAME}" ]
  do
    title "Network Setup"
    wprintf "[?] Set your hostname: "
    read HOST_NAME
    clear
  done

  return $SUCCESS
}

# get available network interfaces
get_net_ifs()
{
  NET_IFS="$(ls /sys/class/net)"

  return $SUCCESS
}


# ask user for network interface
ask_net_if()
{
  while true
  do
    title "Network Setup"
    wprintf "[+] Available network interfaces:"
    printf "\n\n"
    for i in ${NET_IFS}
    do
      echo "    > ${i}"
    done
    echo
    wprintf "[?] Please choose a network interface: "
    read NET_IF
    if echo ${NET_IFS} | grep "\<${NET_IF}\>" > /dev/null
    then
      clear
      break
    fi
    clear
  done

  return $SUCCESS
}


# ask for networking configuration mode
ask_net_conf_mode()
{
  while [ \
    "${NET_CONF_MODE}" != "${NET_CONF_AUTO}" -a \
    "${NET_CONF_MODE}" != "${NET_CONF_WLAN}" -a \
    "${NET_CONF_MODE}" != "${NET_CONF_MANUAL}" -a \
    "${NET_CONF_MODE}" != "${NET_CONF_SKIP}" ]
  do
    title "Network Setup"
    wprintf "[+] Network interface configuration:"
    printf "\n
  1. Auto DHCP (use this for auto connect via dhcp on selected interface)
  2. WiFi WPA Setup (use if you need to connect to a wlan before)
  3. Manual (use this if you are 1337)
  4. Skip (use this if you are already connected)\n\n"
    wprintf "[?] Please choose a mode: "
    read NET_CONF_MODE
    clear
  done

  return $SUCCESS
}


# ask for network addresses
ask_net_addr()
{
  while [ \
    "${HOST_IPV4}" = "" -o "${GATEWAY}" = "" -o "${SUBNETMASK}" = "" \
    -o "${BROADCAST}" = "" -o "${NAMESERVER}" = "" ]
  do
    title "Network Setup"
    wprintf "[+] Configuring network interface '${NET_IF}' via USER: "
    printf "\n
  > Host ipv4
  > Gateway ipv4
  > Subnetmask
  > Broadcast
  > Nameserver
    \n"
    wprintf "[?] Host IPv4: "
    read HOST_IPV4
    wprintf "[?] Gateway IPv4: "
    read GATEWAY
    wprintf "[?] Subnetmask: "
    read SUBNETMASK
    wprintf "[?] Broadcast: "
    read BROADCAST
    wprintf "[?] Nameserver: "
    read NAMESERVER
    clear
  done

  return $SUCCESS
}


# manual network interface configuration
net_conf_manual()
{
  ip addr flush dev ${NET_IF}
  ip link set ${NET_IF} up
  ip addr add ${HOST_IPV4}/${SUBNETMASK} broadcast ${BROADCAST} dev ${NET_IF}
  ip route add default via ${GATEWAY}
  echo "nameserver ${NAMESERVER}" > /etc/resolv.conf

  return $SUCCESS
}


# auto (dhcp) network interface configuration
net_conf_auto()
{
  opts="-h noleak -i noleak -v ,noleak -I noleak"

  title "Network Setup"
  wprintf "[+] Configuring network interface '${NET_IF}' via DHCP: "
  printf "\n\n"

  dhcpcd ${opts} -i ${NET_IF}

  return $SUCCESS
}


# ask for wlan data (ssid, wpa passphrase, etc.)
ask_wlan_data()
{
  while [ "${WLAN_SSID}" = "" -o "${WLAN_PASSPHRASE}" = "" ]
  do
    title "Network Setup"
    wprintf "[+] Configuring network interface '${NET_IF}' via W-LAN + DHCP: "
    printf "\n
  > W-LAN SSID
  > WPA Passphrase (will not echo)
    \n"
    wprintf "[?] W-LAN SSID: "
    read WLAN_SSID
    wprintf "[?] WPA Passphrase: "
    read -s WLAN_PASSPHRASE
    clear
  done

  return $SUCCESS
}


# wifi and auto dhcp network interface configuration
net_conf_wlan()
{
  wpasup="$(mktemp)"
  dhcp_opts="-h noleak -i noleak -v ,noleak -I noleak"

  title "Network Setup"
  wprintf "[+] Configuring network interface '${NET_IF}' via W-LAN + DHCP: "
  printf "\n\n"

  wpa_passphrase "${WLAN_SSID}" "${WLAN_PASSPHRASE}" > ${wpasup}
  wpa_supplicant -B -c ${wpasup} -i ${NET_IF}

  warn "We need to wait a bit for wpa_supplicant and dhcpcd"

  sleep 10

  dhcpcd ${dhcp_opts} -i ${NET_IF}

  sleep 10

  return $SUCCESS
}


# check for internet connection
check_inet_conn()
{
  title "Network Setup"
  wprintf "[+] Checking for Internet connection..."

  if ! wget -q --tries=5 --timeout=10 --spider \
    http://github.com > /dev/null 2>&1
  then
    err "No Internet connection! Check your network (settings)."
  fi

  return $SUCCESS
}


# ask user for luks encrypted partition
ask_luks()
{
  while [ "${LUKS}" = "" ]
  do
    if confirm "Hard Drive Setup" "[?] Full encrypted root [y/n]: "
    then
      LUKS=$TRUE
      echo
      warn "The root partition will be encrypted"
    else
      LUKS=$FALSE
      echo
      warn "The root partition will NOT be encrypted"
    fi
    sleep_clear 2
  done
  return $SUCCESS
}


# get available hard disks
get_hd_devs()
{
  HD_DEVS="$(lsblk | grep disk | awk '{print $1}')"

  return $SUCCESS
}


# ask user for device to format and setup
ask_hd_dev()
{
  while true
  do
    title "Hard Drive Setup"

    wprintf "[+] Available hard drives for installation:"
    printf "\n\n"

    for i in ${HD_DEVS}
    do
      echo "    > ${i}"
    done
    echo
    wprintf "[?] Please choose a device: "
    read HD_DEV
    if echo ${HD_DEVS} | grep "\<${HD_DEV}\>" > /dev/null
    then
      HD_DEV="/dev/${HD_DEV}"
      clear
      break
    fi
    clear
  done


  return $SUCCESS
}


# ask user to create partitions using cfdisk
ask_cfdisk()
{
  if confirm "Hard Drive Setup" "[?] Create partitions with cfdisk (root and \
boot, optional swap) [y/n]: "
  then
    clear
    zero_part
  else
    echo
    warn "You chosed not to make partitions. Make sure you have them already configured."
  fi

  return $SUCCESS
}


# zero out partition if needed/chosen
zero_part()
{
  if confirm "Hard Drive Setup" "[?] Start with an in-memory zeroed \
partition table [y/n]: "
  then
    cfdisk -z "${HD_DEV}"
    sync
  else
    cfdisk "${HD_DEV}"
    sync
  fi

  return $SUCCESS
}


# get partition label
get_partition_label()
{
  PART_LABEL="$(parted -m ${HD_DEV} print | grep ${HD_DEV} | cut -d ':' -f 6)"

  return $SUCCESS
}


# get partitions
ask_partitions()
{
  partitions=$(ls ${HD_DEV}* | grep -v "${HD_DEV}\>")

  while [ \
    "${BOOT_PART}" = "" -o \
    "${ROOT_PART}" = "" -o \
    "${BOOT_FS_TYPE}" = "" -o \
    "${ROOT_FS_TYPE}" = "" ]
  do
    title "Hard Drive Setup"
    wprintf "[+] Created partitions:"
    printf "\n\n"

    for i in ${partitions}
    do
      echo "    > ${i}"
    done
    echo

    wprintf "[?] Boot partition (/dev/sdXY): "
    read BOOT_PART
    wprintf "[?] Boot FS type (ext2, ext3, ext4, btrfs, fat32): "
    read BOOT_FS_TYPE
    wprintf "[?] Root partition (/dev/sdXY): "
    read ROOT_PART
    wprintf "[?] Root FS type (ext2, ext3, ext4, btrfs): "
    read ROOT_FS_TYPE
    wprintf "[?] Swap parition (/dev/sdXY - empty for none): "
    read SWAP_PART

    if [ "${SWAP_PART}" = "" ]
    then
      SWAP_PART="none"
    fi
    clear
  done

  return $SUCCESS
}


# print partitions and ask for confirmation
print_partitions()
{
  i=""

  while true
  do
    title "Hard Drive Setup"
    wprintf "[+] Current Partition table"
    printf "\n
  > /boot   : ${BOOT_PART} (${BOOT_FS_TYPE})
  > /       : ${ROOT_PART} (${ROOT_FS_TYPE})
  > swap    : ${SWAP_PART} (swap)
  \n"
    wprintf "[?] Partition table correct [y/n]: "
    read i
    if [ "${i}" = "y" -o "${i}" = "Y" ]
    then
      clear
      break
    elif [ "${i}" = "n" -o "${i}" = "N" ]
    then
      echo
      err "Hard Drive Setup aborted."
    else
      clear
      continue
    fi
    clear
  done

  return $SUCCESS
}


# ask user and get confirmation for formatting
ask_formatting()
{
  if confirm "Hard Drive Setup" "[?] Formatting partitions. Are you sure? \
No crying afterwards? [y/n]: "
  then
    return $SUCCESS
  else
    echo
    err "Seriously? No formatting no fun!"
  fi

  return $SUCCESS
}


# create LUKS encrypted partition
make_luks_partition()
{
  part="${1}"

  title "Hard Drive Setup"

  wprintf "[+] Creating LUKS partition"
  printf "\n\n"

  cryptsetup -q -y -v -s 512 luksFormat "${part}" ||
    err "Could not create filesystem"

  return $SUCCESS
}


# open LUKS partition
open_luks_partition()
{
  part="${1}"
  name="${2}"

  title "Hard Drive Setup"

  wprintf "[+] Opening LUKS partition"
  printf "\n\n"
  cryptsetup open "${part}" "${name}"

  return $SUCCESS
}


# create swap partition
make_swap_partition()
{
  title "Hard Drive Setup"

  wprintf "[+] Creating SWAP partition"
  printf "\n\n"
  mkswap "${SWAP_PART}" || err "Could not create filesystem"

  return $SUCCESS
}


# make and format root partition
make_root_partition()
{
  if [ ${LUKS} = ${TRUE} ]
  then
    make_luks_partition "${ROOT_PART}"
    sleep_clear 1
    open_luks_partition "${ROOT_PART}" "${CRYPT_ROOT}"
    sleep_clear 1
    title "Hard Drive Setup"
    wprintf "[+] Creating encrypted ROOT partition"
    printf "\n\n"
    if [ "${ROOT_FS_TYPE}" = "btrfs" ]
    then
      mkfs.${ROOT_FS_TYPE} -f "/dev/mapper/${CRYPT_ROOT}" ||
        err "Could not create filesystem"
    else
      mkfs.${ROOT_FS_TYPE} -F "/dev/mapper/${CRYPT_ROOT}" ||
        err "Could not create filesystem"
    fi
    sleep_clear 1
  else
    title "Hard Drive Setup"
    wprintf "[+] Creating ROOT partition"
    printf "\n\n"
    if [ "${ROOT_FS_TYPE}" = "btrfs" ]
    then
      mkfs.${ROOT_FS_TYPE} -f ${ROOT_PART} ||
        err "Could not create filesystem"
    else
      mkfs.${ROOT_FS_TYPE} -F ${ROOT_PART} ||
        err "Could not create filesystem"
    fi
    sleep_clear 1
  fi

  return $SUCCESS
}


# make and format boot partition
make_boot_partition()
{
  title "Hard Drive Setup"

  wprintf "[+] Creating BOOT partition"
  printf "\n\n"
  if [ "${PART_LABEL}" = "gpt" ]
  then
    mkfs.fat -F32 ${BOOT_PART} || err "Could not create filesystem"
  else
    mkfs.${BOOT_FS_TYPE} -F ${BOOT_PART} ||
      err "Could not create filesystem"
  fi

  return $SUCCESS
}


# make and format partitions
make_partitions()
{
  make_boot_partition
  sleep_clear 1

  make_root_partition
  sleep_clear 1

  if [ "${SWAP_PART}" != "none" ]
  then
    make_swap_partition
    sleep_clear 1
  fi

  return $SUCCESS
}


# mount filesystems
mount_filesystems()
{
  title "Hard Drive Setup"

  wprintf "[+] Mounting filesystems"
  printf "\n\n"

  # ROOT
  if [ ${LUKS} = ${TRUE} ]
  then
    mount "/dev/mapper/${CRYPT_ROOT}" ${CHROOT} > /dev/null 2>&1
  else
    mount ${ROOT_PART} ${CHROOT} > /dev/null 2>&1
  fi

  # BOOT
  mkdir ${CHROOT}/boot > /dev/null 2>&1
  mount ${BOOT_PART} "${CHROOT}/boot" > /dev/null 2>&1

  # SWAP
  swapon "${SWAP_PART}" > /dev/null 2>&1

  return $SUCCESS
}


# unmount filesystems
umount_filesystems()
{
  routine="${1}"

  if [ "${routine}" = "harddrive" ]
  then
    title "Hard Drive Setup"
  else
    title "Game Over"
  fi

  wprintf "[+] Unmounting filesystems"
  printf "\n\n"

  # hardcore style ... TODO: tune this
  umount -Rf ${CHROOT} > ${VERBOSE} 2>&1
  umount -Rf "${BOOT_PART}" > ${VERBOSE} 2>&1
  umount -Rf "${CHROOT}/proc" > ${VERBOSE} 2>&1
  umount -Rf "${CHROOT}/sys" > ${VERBOSE} 2>&1
  umount -Rf "${CHROOT}/dev" > ${VERBOSE} 2>&1
  umount -Rf "${BOOT_PART}" > ${VERBOSE} 2>&1
  umount -Rf "${ROOT_PART}" > ${VERBOSE} 2>&1
  umount -Rf "/dev/mapper/${CRYPT_ROOT}" > ${VERBOSE} 2>&1
  cryptsetup luksClose "${CRYPT_ROOT}" > ${VERBOSE} 2>&1
  swapoff "${SWAP_PART}" > ${VERBOSE} 2>&1

  return $SUCCESS
}


# install ArchLinux base and base-devel packages
install_base_packages()
{
  title "Base System Setup"

  wprintf "[+] Installing ArchLinux base packages"
  printf "\n\n"

  pacstrap ${CHROOT} base base-devel terminus-font
  chroot ${CHROOT} pacman -Syy --force

  return $SUCCESS
}


# setup /etc/resolv.conf
setup_resolvconf()
{
  title "Base System Setup"

  wprintf "[+] Setting up /etc/resolv.conf"
  printf "\n\n"

  mkdir -p "${CHROOT}/etc/" > ${VERBOSE} 2>&1
  cp -L "/etc/resolv.conf" "${CHROOT}/etc/resolv.conf" > ${VERBOSE} 2>&1

  return $SUCCESS
}


# setup fstab
setup_fstab()
{
  title "Base System Setup"

  wprintf "[+] Setting up /etc/fstab"
  printf "\n\n"

  if [ "${PART_LABEL}" = "gpt" ]
  then
    genfstab -U ${CHROOT} >> "${CHROOT}/etc/fstab"
  else
    genfstab -L ${CHROOT} >> "${CHROOT}/etc/fstab"
  fi

  return $SUCCESS
}


# setup locale and keymap
setup_locale()
{
  title "Base System Setup"

  wprintf "[+] Setting up default locale (en_US.UTF-8)"
  printf "\n\n"

  sed -i 's/^#en_US.UTF-8/en_US.UTF-8/' "${CHROOT}/etc/locale.gen"
  chroot ${CHROOT} locale-gen
  echo "KEYMAP=${KEYMAP}" > "${CHROOT}/etc/vconsole.conf"

  return $SUCCESS
}


# setup timezone
setup_time()
{
  if confirm "Default Time zone: UTC" "[?] Choose other timezone [y/n]: "
  then
    for t in $(timedatectl list-timezones)
    do
      echo "    > $(echo ${t})"
    done

    wprintf "\n[?] What is your (Zone/SubZone): "
    read timezone
    chroot ${CHROOT} ln -sf /usr/share/zoneinfo/${timezone} /etc/localtime \
      > ${VERBOSE} 2>&1

    if [ $? -eq 1 ]
    then
      warn "Do you live on Mars? Setting default time zone..."
      sleep 1
      default_time
    else
      wprintf "\n[+] Time zone setup correctly\n"
    fi
  else
    wprintf "\n[+] Setting up default time and timezone\n"
    sleep 2
    default_time
  fi

  printf "\n"

  return $SUCCESS
}


# default time and timezone
default_time()
{
  echo
  warn "Setting up default time and timezone: UTC"
  printf "\n\n"
  chroot ${CHROOT} ln -sf /usr/share/zoneinfo/UTC /etc/localtime

  return $SUCCESS
}


# setup initramfs
setup_initramfs()
{
  title "Base System Setup"

  wprintf "[+] Setting up initramfs"
  printf "\n\n"

  if [ "${INSTALL_MODE}" = "${INSTALL_LIVE_ISO}" ]
  then
    cp /run/archiso/bootmnt/blackarch/boot/x86_64/vmlinuz \
      ${CHROOT}/boot/vmlinuz-linux
  fi

  # terminus font
  sed -i 's/keyboard fsck/keyboard fsck consolefont/g' \
    "${CHROOT}/etc/mkinitcpio.conf"
  echo 'FONT=ter-114n' >> "${CHROOT}/etc/vconsole.conf"

  if [ ${LUKS} = ${TRUE} ]
  then
    sed -i 's/block filesystems/block keymap encrypt filesystems/g' \
      "${CHROOT}/etc/mkinitcpio.conf"
  fi

  chroot ${CHROOT} mkinitcpio -p linux

  return $SUCCESS
}


# mount /proc, /sys and /dev
setup_proc_sys_dev()
{
  title "Base System Setup"

  wprintf "[+] Setting up /proc, /sys and /dev"
  printf "\n\n"

  mkdir -p "${CHROOT}/"{proc,sys,dev} > /dev/null 2>&1

  mount -t proc proc "${CHROOT}/proc"
  mount --rbind /sys "${CHROOT}/sys"
  mount --make-rslave "${CHROOT}/sys"
  mount --rbind /dev "${CHROOT}/dev"
  mount --make-rslave "${CHROOT}/dev"

  return $SUCCESS
}


# setup hostname
setup_hostname()
{
  title "Base System Setup"

  wprintf "[+] Setting up hostname"
  printf "\n\n"

  echo "${HOST_NAME}" > "${CHROOT}/etc/hostname"

  return $SUCCESS
}


# setup boot loader for UEFI/GPT or BIOS/MBR
setup_bootloader()
{
  title "Base System Setup"

  if [ "${PART_LABEL}" = "gpt" ]
  then
    wprintf "[+] Setting up EFI boot loader"
    printf "\n\n"

    chroot ${CHROOT} bootctl install
    uuid="$(blkid ${ROOT_PART} | cut -d ' ' -f 2 | cut -d '"' -f 2)"

    if [ ${LUKS} = ${TRUE} ]
    then
      cat >> "${CHROOT}/boot/loader/entries/arch.conf" << EOF
title   BlackArch Linux
linux   /vmlinuz-linux
initrd    /initramfs-linux.img
options   cryptdevice=UUID=${uuid}:${CRYPT_ROOT} root=/dev/mapper/${CRYPT_ROOT} rw
EOF

    else
      cat >> "${CHROOT}/boot/loader/entries/arch.conf" << EOF
title   BlackArch Linux
linux   /vmlinuz-linux
initrd    /initramfs-linux.img
options   root=UUID=${uuid} rw
EOF
    fi
  else
    wprintf "[+] Setting up GRUB boot loader"
    printf "\n\n"

    uuid="$(lsblk -o UUID ${ROOT_PART} | sed -n 2p)"

    if [ "${INSTALL_MODE}" != "${INSTALL_LIVE_ISO}" ]
    then
      chroot ${CHROOT} pacman -S grub --noconfirm --force --needed
    else
      mkdir -p ${CHROOT}/boot/grub
    fi

    cp ${BI_PATH}/data/boot/grub/splash.png ${CHROOT}/boot/grub/splash.png

    if [ ${LUKS} = ${TRUE} ]
    then
      sed -i "s|quiet|cryptdevice=UUID=${uuid}:${CRYPT_ROOT} root=/dev/mapper/${CRYPT_ROOT}|" \
        "${CHROOT}/etc/default/grub"
    fi
    sed -i 's/quiet//g' "${CHROOT}/etc/default/grub"
    sed -i 's/Arch/BlackArch/g' "${CHROOT}/etc/default/grub"
    echo "GRUB_BACKGROUND=\"/boot/grub/splash.png\"" >> \
      "${CHROOT}/etc/default/grub"
    chroot ${CHROOT} grub-install --target=i386-pc "${HD_DEV}"
    chroot ${CHROOT} grub-mkconfig -o /boot/grub/grub.cfg
    sed -i 's/Arch Linux/BlackArch Linux/g' "${CHROOT}/boot/grub/grub.cfg"
    chroot ${CHROOT} grub-mkconfig -o /boot/grub/grub.cfg
  fi

  return $SUCCESS
}


# ask for normal user account to setup
ask_user_account()
{
  if confirm "Base System Setup" "[?] Setup a normal user account [y/n]: "
  then
    wprintf "[?] User name: "
    read NORMAL_USER
  fi

  return $SUCCESS
}


# setup blackarch test user (not active + lxdm issue)
setup_testuser()
{
  title "Base System Setup"

  wprintf "[+] Setting up test user blackarchtest account"
  printf "\n\n"
  warn "Remove this user after you added a normal system user account"
  printf "\n"

  chroot ${CHROOT} groupadd blackarchtest
  chroot ${CHROOT} useradd -g blackarchtest -d /home/blackarchtest/ \
    -s /sbin/nologin -m blackarchtest
}


# setup user account, password and environment
setup_user()
{
  user="${1}"

  title "Base System Setup"

  wprintf "[+] Setting up ${user} account"
  printf "\n\n"

  # normal user
  if [ ! -z ${NORMAL_USER} ]
  then
    chroot ${CHROOT} groupadd ${user}
    chroot ${CHROOT} useradd -g ${user} -d "/home/${user}" -s "/bin/bash" \
      -G "${user},wheel,users,video,audio" -m ${user} > ${VERBOSE} 2>&1
    chroot ${CHROOT} chown -R ${user}:${user} "/home/${user}"
    wprintf "[+] Added user: ${user}"
    printf "\n\n"
  fi

  # environment
  if [ -z ${NORMAL_USER} ]
  then
    cp -r ${BI_PATH}/data/root/. "${CHROOT}/root/." > ${VERBOSE} 2>&1
  else
    cp -r ${BI_PATH}/data/user/. "${CHROOT}/home/${user}/." > ${VERBOSE} 2>&1
  fi

  # password
  res=1337
  wprintf "[?] Set password for ${user}: "
  printf "\n\n"
  while [ $res -ne 0 ]
  do
    if [ "${user}" = "root" ]
    then
      chroot ${CHROOT} passwd
    else
      chroot ${CHROOT} passwd "${user}"
    fi
    res=$?
  done

  return $SUCCESS
}


# install extra (missing) packages
setup_extra_packages()
{
  arch="arch-install-scripts archlinux-keyring pkgfile"

  bluetooth="bluez bluez-firmware bluez-hid2hci bluez-utils"

  browser="firefox chromium elinks"

  editor="vim"

  filesystem="btrfs-progs cryptsetup device-mapper dmraid dosfstools
  gptfdisk nilfs-utils ntfs-3g partclone parted partimage"

  fonts="ttf-liberation ttf-dejavu ttf-freefont xorg-font-utils
  xorg-fonts-alias xorg-fonts-misc xorg-mkfontscale xorg-mkfontdir
  ttf-indic-otf"

  kernel="linux-api-headers linux-headers"

  misc="acpi alsa-utils b43-fwcutter bash-completion bc btrfs-progs cmake
  ctags expac feh flashplugin git gpm grml-zsh-config haveged hdparm htop
  inotify-tools ipython irssi linux-atm lsof mercurial mesa mlocate moreutils
  mpv mtools p7zip rsync rtorrent scrot smartmontools speedtouch strace sudo
  tzdata unace unrar unzip usb_modeswitch zip zsh"

  network="wicd-gtk wicd bridge-utils darkhttpd atftp bind-tools dnsmasq
  dhclient dnsutils gnu-netcat ipw2100-fw ipw2200-fw lftp nfs-utils ntp
  openconnect openssh openvpn ppp pptpclient rfkill rp-pppoe vpnc dialog iw
  wireless_tools wpa_actiond wvdial xl2tpd zd1211-firmware wpa_supplicant"

  xorg="xf86-video-amdgpu xf86-video-ati xf86-video-dummy xf86-video-fbdev
  xf86-video-intel xf86-video-nouveau xf86-video-openchrome xf86-video-sisusb
  xf86-video-vesa xf86-video-voodoo xorg-server xorg-xinit xterm"

  all="${arch} ${bluetooth} ${browser} ${editor} ${filesystem} ${fonts}"
  all="${all} ${kernel} ${misc} ${network} ${xorg}"

  title "Base System Setup"

  wprintf "[+] Installing extra packages"
  printf "\n"

  printf "
  > ArchLinux   : `echo ${arch} | wc -w` packages
  > Browser     : `echo ${browser} | wc -w` packages
  > Bluetooth   : `echo ${bluetooth} | wc -w` packages
  > Editor      : `echo ${editor} | wc -w` packages
  > Filesystem  : `echo ${filesystem} | wc -w` packages
  > Fonts       : `echo ${fonts} | wc -w` packages
  > Misc        : `echo ${misc} | wc -w` packages
  > Network     : `echo ${network} | wc -w` packages
  > Xorg        : `echo ${xorg} | wc -w` packages
  \n"

  sleep 2

  chroot ${CHROOT} pacman -S --needed --force --noconfirm $(echo ${all})

  return $SUCCESS
}


# perform system base setup/configurations
setup_base_system()
{
  if [ "${INSTALL_MODE}" = "${INSTALL_LIVE_ISO}" ]
  then
    dump_live_iso
    sleep_clear 1
  fi

  if [ "${INSTALL_MODE}" != "${INSTALL_LIVE_ISO}" ]
  then
    setup_resolvconf
    sleep_clear 1

    install_base_packages
    sleep_clear 1

    setup_resolvconf
    sleep_clear 1
  fi

  setup_fstab
  sleep_clear 1

  setup_proc_sys_dev
  sleep_clear 1

  setup_locale
  sleep_clear 1

  setup_initramfs
  sleep_clear 1

  setup_hostname
  sleep_clear 1

  setup_user "root"
  sleep_clear 1

  ask_user_account
  sleep_clear 1

  if [ ! -z "${NORMAL_USER}" ]
  then
    setup_user "${NORMAL_USER}"
    sleep_clear 1
  else
    setup_testuser
    sleep_clear 2
  fi

  if [ "${INSTALL_MODE}" != "${INSTALL_LIVE_ISO}" ]
  then
    setup_extra_packages
    sleep_clear 1
  fi

  setup_bootloader
  sleep_clear 1

  return $SUCCESS
}


# update /etc files
update_etc()
{
  title "BlackArch Linux Setup"

  wprintf "[+] Updating /etc files"
  printf "\n\n"

  # /etc/*
  cp -r ${BI_PATH}/data/etc/. ${CHROOT}/etc/. > ${VERBOSE} 2>&1

  return $SUCCESS
}


# ask for blackarch linux mirror
ask_mirror()
{
  title "BlackArch Linux Setup"

  local IFS='|'
  count=1
  mirror_url="https://raw.githubusercontent.com/BlackArch/blackarch/master/mirror/mirror.lst"
  mirror_file="/tmp/mirror.lst"

  wprintf "[+] Fetching mirror list"
  printf "\n\n"
  curl -s -o "${mirror_file}" "${mirror_url}"

  while read -r country url mirror_name
  do
    wprintf " %s. %s - %s" "${count}" "${country}" "${mirror_name}"
    printf "\n"
    wprintf "   * %s" "${url}"
    printf "\n"
    count=`expr $count + 1`
  done < "${mirror_file}"

  printf "\n"
  wprintf "[?] Select a mirror number (enter for default): "
  read a
  printf "\n"

  # bugfix: detected chars added sometimes - clear chars
  _a=`printf "%s" $a | sed 's/[a-z]//Ig' 2> /dev/null`

  if [ -z "${_a}" ]
  then
    wprintf "[+] Choosing default mirror: %s " "${BA_REPO_URL}"
  else
    BA_REPO_URL=`sed -n "${_a}p" "${mirror_file}" | cut -d "|" -f 2`
    wprintf "[+] Mirror from '%s' selected" \
      `sed -n "${_a}p" "${mirror_file}" | cut -d "|" -f 3`
    printf "\n\n"
  fi

  rm -f "${mirror_file}"

  return $SUCCESS
}

# ask for archlinux server
ask_mirror_arch()
{
  declare mirrold="cp /etc/pacman.d/mirrorlist /etc/pacman.d/mirrorlist.backup"

  if confirm "ArchLinux Mirrorlist Setup" \
    "[+] Worldwide mirror will be used\n\n[?] Look for the best server [y/n]: "
  then
    printf "\n"
    warn "This may take time depending on your connection"
    $mirrold
    pacman -Syy --noconfirm > ${VERBOSE} 2>&1
    pacman -S --noconfirm pacman-contrib > ${VERBOSE} 2>&1
    sed -i 's/^#Server/Server/' /etc/pacman.d/mirrorlist.backup
    rankmirrors -n 3 /etc/pacman.d/mirrorlist.backup \
      > /etc/pacman.d/mirrorlist
  else
    printf "\n"
    warn "Using Worldwide mirror server"
    $mirrold
    echo -e "## Arch Linux repository Worldwide mirrorlist\n\n" \
      > /etc/pacman.d/mirrorlist

    for wore in ${AR_REPO_URL}
    do
      echo "Server = ${wore}" >> /etc/pacman.d/mirrorlist
    done
  fi

}

# pass correct config
pass_mirror_conf()
{
  cp -f /etc/pacman.d/mirrorlist ${CHROOT}/etc/pacman.d/mirrorlist \
    > ${VERBOSE} 2>&1
}


# run strap.sh
run_strap_sh()
{
  strap_sh="/tmp/strap.sh"
  orig_sha1="$(curl -s https://blackarch.org/checksums/strap)"

  title "BlackArch Linux Setup"

  wprintf "[+] Downloading and executing strap.sh"
  printf "\n\n"

  curl -s -o "${strap_sh}" "https://www.blackarch.org/strap.sh"
  sha1="$(sha1sum ${strap_sh} | awk '{print $1}')"

  if [ "${sha1}" = "${orig_sha1}" ]
  then
    mv ${strap_sh} "${CHROOT}${strap_sh}"
    chmod a+x "${CHROOT}${strap_sh}"
    chroot ${CHROOT} echo ${BA_REPO_URL} | sh ${CHROOT}${strap_sh}
  else
    err "Wrong SHA1 sum for strap.sh: ${sha1} (orig: ${orig_sha1}). Aborting!"
  fi

  # add blackarch linux mirror if we are in chroot
  if ! grep -q "blackarch" "${CHROOT}/etc/pacman.conf"
  then
    printf '[blackarch]\nServer = %s\n' "${BA_REPO_URL}" \
      >> "${CHROOT}/etc/pacman.conf"
  else
    sed -i "/\[blackarch\]/{ n;s?Server.*?Server = ${BA_REPO_URL}?; }" \
      "${CHROOT}/etc/pacman.conf"
  fi

  return $SUCCESS
}


# ask user for X (display + window manager) setup
ask_x_setup()
{
  if confirm "BlackArch Linux Setup" "[?] Setup X11 + window managers [y/n]: "
  then
    X_SETUP=$TRUE
    printf "\n"
    printf "${BLINK}NOOB! NOOB! NOOB! NOOB! NOOB! NOOB! NOOB!${NC}\n\n"
  fi

  return $SUCCESS
}


# setup display manager
setup_display_manager()
{
  title "BlackArch Linux Setup"

  wprintf "[+] Setting up LXDM"
  printf "\n"

  printf "
  > Lxdm
  \n"

  sleep 2

  # install lxdm packages
  chroot ${CHROOT} pacman -S lxdm --needed --force --noconfirm

  # config files
  cp -r ${BI_PATH}/data/etc/lxdm/. ${CHROOT}/etc/lxdm/.
  cp -r ${BI_PATH}/data/usr/share/lxdm/. ${CHROOT}/usr/share/lxdm/.
  cp -r ${BI_PATH}/data/usr/share/xsessions/. ${CHROOT}/usr/share/xsessions/
  cp -r ${BI_PATH}/data/usr/share/gtk-2.0/. ${CHROOT}/usr/share/gtk-2.0/.

  # enable in systemd
  chroot ${CHROOT} systemctl enable lxdm

  return $SUCCESS
}


# setup window managers
setup_window_managers()
{
  title "BlackArch Linux Setup"

  wprintf "[+] Setting up window managers"
  printf "\n"

  while true
  do
    printf "
  1. Awesome
  2. Dwm
  3. Fluxbox
  4. I3-wm
  5. Openbox
  6. Spectrwm
  7. All of the above
  \n"
    wprintf "[?] Choose an option [7]: "
    read choice
    echo
    case $choice in
      1)
        chroot ${CHROOT} pacman -S awesome --needed --force --noconfirm
        cp -r ${BI_PATH}/data/etc/xdg/awesome/. \
          ${CHROOT}/etc/xdg/awesome/.
        cp -r ${BI_PATH}/data/usr/share/awesome/. \
          ${CHROOT}/usr/share/awesome/.
        # fix bullshit exit() issue
        sed -i 's|local visible, action = cmd(item, self)|local visible, action = cmd(0, 0)|' \
          ${CHROOT}/usr/share/awesome/lib/awful/menu.lua
        break
        ;;
      2)
        chroot ${CHROOT} pacman -S dwm --needed --force --noconfirm
        break
        ;;
      3)
        chroot ${CHROOT} pacman -S fluxbox --needed --force --noconfirm
        cp -r ${BI_PATH}/data/usr/share/fluxbox/. \
          ${CHROOT}/usr/share/fluxbox/.
        break
        ;;
      4)
        chroot ${CHROOT} pacman -S i3-wm i3status i3lock dmenu --needed \
          --force --noconfirm
        cp -r ${BI_PATH}/data/root/{.config,.i3status.conf} \
          ${CHROOT}/root/.
        break
        ;;
      5)
        chroot ${CHROOT} pacman -S openbox --needed --force --noconfirm
        cp -r ${BI_PATH}/data/etc/xdg/openbox/. \
          ${CHROOT}/etc/xdg/openbox/.
        cp -r ${BI_PATH}/data/usr/share/themes/blackarch \
          ${CHROOT}/usr/share/themes/i3lock .
        break
        ;;
      6)
        chroot ${CHROOT} pacman -S spectrwm --needed --force --noconfirm
        cp -r ${BI_PATH}/data/etc/spectrwm.conf \
          ${CHROOT}/etc/spectrwm.conf
        break
        ;;
      *)
        chroot ${CHROOT} pacman -S fluxbox openbox awesome i3-wm i3status \
          i3lock dwm spectrwm --needed --force --noconfirm

        # awesome
        cp -r ${BI_PATH}/data/etc/xdg/awesome/. \
          ${CHROOT}/etc/xdg/awesome/.
        cp -r ${BI_PATH}/data/usr/share/awesome/. \
          ${CHROOT}/usr/share/awesome/.
        sed -i 's|local visible, action = cmd(item, self)|local visible, action = cmd(0, 0)|' \
          ${CHROOT}/usr/share/awesome/lib/awful/menu.lua

        # fluxbox
        cp -r ${BI_PATH}/data/usr/share/fluxbox/. \
          ${CHROOT}/usr/share/fluxbox/.

        # i3
        cp -r ${BI_PATH}/data/root/{.config,.i3status.conf} \
          ${CHROOT}/root/.

        # openbox
        cp -r ${BI_PATH}/data/etc/xdg/openbox/. \
          ${CHROOT}/etc/xdg/openbox/.
        cp -r ${BI_PATH}/data/usr/share/themes/blackarch \
          ${CHROOT}/usr/share/themes/.

        # spectrwm
        cp -r ${BI_PATH}/data/etc/spectrwm.conf \
          ${CHROOT}/etc/spectrwm.conf

        # wmii
        cp -r ${BI_PATH}/data/etc/wmii/. ${CHROOT}/etc/wmii/.

        break
        ;;
    esac
  done

  # wallpaper
  cp -r ${BI_PATH}/data/usr/share/blackarch ${CHROOT}/usr/share/blackarch

  # remove wrong xsession entries
  chroot ${CHROOT} rm "/usr/share/xsessions/openbox-kde.desktop" \
    > ${VERBOSE} 2>&1
  chroot ${CHROOT} rm "/usr/share/xsessions/i3-with-shmlog.desktop" \
    > ${VERBOSE} 2>&1

  return $SUCCESS
}


# ask user for VirtualBox modules+utils setup
ask_vbox_setup()
{
  if confirm "BlackArch Linux Setup" "[?] Setup VirtualBox modules [y/n]: "
  then
    VBOX_SETUP=$TRUE
  fi

  return $SUCCESS
}


# setup virtualbox utils
setup_vbox_utils()
{
  title "BlackArch Linux Setup"

  wprintf "[+] Setting up VirtualBox utils"
  printf "\n\n"

  chroot ${CHROOT} pacman -S virtualbox-guest-utils \
    virtualbox-guest-modules-arch --force --needed --noconfirm

  chroot ${CHROOT} systemctl enable vboxservice
  chroot ${CHROOT} systemctl enable vboxadd
  chroot ${CHROOT} systemctl enable vboxadd-service
  chroot ${CHROOT} systemctl enable vboxadd-x11

  printf "vboxguest\nvboxsf\nvboxvideo\n" \
    > "${CHROOT}/etc/modules-load.d/vbox.conf"

  return $SUCCESS
}


# ask user for VirtualBox modules+utils setup
ask_vmware_setup()
{
  if confirm "BlackArch Linux Setup" "[?] Setup VMware modules [y/n]: "
  then
    VMWARE_SETUP=$TRUE
  fi

  return $SUCCESS
}


# setup vmware utils
setup_vmware_utils()
{
  title "BlackArch Linux Setup"

  wprintf "[+] Setting up VMware utils"
  printf "\n\n"

  chroot ${CHROOT} pacman -S open-vm-tools xf86-video-vmware \
    xf86-input-vmmouse --force --needed --noconfirm

  chroot ${CHROOT} systemctl enable vmware-vmblock-fuse.service
  chroot ${CHROOT} systemctl enable vmtoolsd.service

  return $SUCCESS
}


# ask user for BlackArch tools setup
ask_ba_tools_setup()
{
  if confirm "BlackArch Linux Setup" "[?] Setup BlackArch Linux tools [y/n]: "
  then
    BA_TOOLS_SETUP=$TRUE
  fi

  return $SUCCESS
}


# setup blackarch tools from repository (binary) or via blackman (source)
setup_blackarch_tools()
{
  foo=5

  title "BlackArch Linux Setup"

  wprintf "[+] Installing BlackArch Linux packages (grab a coffee)"
  printf "\n\n"

  if [ ${INSTALL_MODE} = ${INSTALL_REPO} ]
  then
    chroot ${CHROOT} pacman -S --needed --force blackarch
  else
    warn "Installing all tools from source via blackman can take hours"
    printf "\n"
    wprintf "[+] <Control-c> to abort ... "
    while [ $foo -gt 0 ]
    do
      wprintf "$foo "
      sleep 1
      foo=`expr $foo - 1`
    done
    printf "\n"
    chroot ${CHROOT} pacman -S --needed --force blackman
    blackman -a
  fi

  return $SUCCESS
}


# add user to newly created groups
update_user_groups()
{
  title "BlackArch Linux Setup"

  wprintf "[+] Adding user '${NORMAL_USER}' to groups"
  printf "\n\n"

  # TODO: more to add here
  if [ $VBOX_SETUP -eq $TRUE ]
  then
    chroot ${CHROOT} usermod -G ${NORMAL_USER},vboxusers > ${VERBOSE} 2>&1
  fi

  return $SUCCESS
}


# dump data from the live-iso
dump_live_iso()
{
  live_dirs="/bin /sbin /etc /home /lib /lib64 /opt /root /srv /usr /var /tmp"

  title "BlackArch Linux Setup"

  wprintf "[+] Dumping data from Live-ISO. Grab a coffee and pop shells!"
  printf "\n\n"

  wprintf "[+] Fetching total size to transfer, please wait..."
  printf "\n"

  for d in ${live_dirs}
  do
    printf "
  > ${d} (`du -sh ${d} 2> /dev/null | awk '{print $1}'`)"
  done
  printf "\n\n"

  wprintf "[+] Installing /, please wait. This will take some time..."
  cp -ax / ${CHROOT}
  wprintf "done\n"

  # clean up files
  wprintf "[+] Cleaning Live Environment files, please wait... "
  sed -i 's/Storage=volatile/#Storage=auto/' ${CHROOT}/etc/systemd/journald.conf
  rm -rf ${CHROOT}/etc/udev/rules.d/81-dhcpcd.rules
  rm -rf ${CHROOT}/etc/systemd/system/{choose-mirror.service,pacman-init.service,etc-pacman.d-gnupg.mount,getty@tty1.service.d}
  rm -ff ${CHROOT}/etc/systemd/scripts/choose-mirror
  rm -ff ${CHROOT}/etc/systemd/system/getty@tty1.service.d/autologin.conf
  rm -ff ${CHROOT}/root/{.automated_script.sh,.zlogin}
  rm -ff ${CHROOT}/etc/mkinitcpio-archiso.conf
  rm -rf ${CHROOT}/etc/initcpio
  #rm -rf ${CHROOT}/etc/{group*,passwd*,shadow*,gshadow*}
  wprintf "done\n"

  return $SUCCESS
}


# setup blackarch related stuff
setup_blackarch()
{
  update_etc
  sleep_clear 1

  ask_mirror
  sleep_clear 1

  run_strap_sh
  sleep_clear 1

  ask_x_setup
  sleep_clear 3

  if [ $X_SETUP -eq $TRUE ]
  then
    setup_display_manager
    sleep_clear 1
    setup_window_managers
    sleep_clear 1
  fi

  ask_vbox_setup
  sleep_clear 1

  if [ $VBOX_SETUP -eq $TRUE ]
  then
    setup_vbox_utils
    sleep_clear 1
  fi

  ask_vmware_setup
  sleep_clear 1

  if [ $VMWARE_SETUP -eq $TRUE ]
  then
    setup_vmware_utils
    sleep_clear 1
  fi

  update_etc
  sleep_clear 1

  enable_pacman_multilib "chroot"
  sleep_clear 1

  enable_pacman_color "chroot"
  sleep_clear 1

  ask_ba_tools_setup
  sleep_clear 1

  if [ $BA_TOOLS_SETUP -eq $TRUE ]
  then
    setup_blackarch_tools
    sleep_clear 1
  fi

  if [ -n "${NORMAL_USER}" ]
  then
    update_user_groups
    sleep_clear 1
  fi

  return $SUCCESS
}


# for fun and lulz
easter_backdoor()
{
  foo=0

  title "Game Over"

  wprintf "[+] BlackArch Linux installation successfull!"
  printf "\n\n"

  wprintf "Yo n00b, b4ckd00r1ng y0ur sy5t3m n0w "
  while [ $foo -ne 5 ]
  do
    wprintf "."
    sleep 1
    foo=`expr $foo + 1`
  done
  printf " >> ${BLINK}${WHITE}HACK THE PLANET! D00R THE PLANET!${NC} <<"
  printf "\n\n"

  return $SUCCESS
}


# perform sync
sync_disk()
{
  title "Game Over"

  wprintf "[+] Syncing disk"
  printf "\n\n"

  sync

  return $SUCCESS
}


# check if new version available. perform self-update and exit
self_updater()
{
  title "Self Updater"
  wprintf "[+] Checking for a new version of myself..."

  pacman -Syy > ${VERBOSE} 2>&1
  ver="v$(pacman -Ss blackarch-installer | head -1 | cut -d ' ' -f 2 |
    cut -d '-' -f 1)"

  if [ "${ver}" != "${VERSION}" ]
  then
    printf "\n\n"
    warn "A new version is available! Going to fuck, err, update myself."
    printf "\n"
    pacman -S --force --noconfirm blackarch-installer
    wprintf "\n[+] Updated successfully. Please restart the installer now!\n"
    chmod +x /usr/share/blackarch-installer/blackarch-install > ${VERBOSE}
    sleep 2
    exit $SUCCESS
  fi

  return $SUCCESS
}


# controller and program flow
main()
{
  clear

  # do some ENV checks
  check_uid
  check_env
  check_iso_type

  # install mode
  ask_install_mode

  # keymap
  ask_keymap
  set_keymap
  clear

  # network
  ask_hostname
  if [ "${INSTALL_MODE}" != "${INSTALL_LIVE_ISO}" ]
  then
    get_net_ifs
    ask_net_conf_mode
    if [ "${NET_CONF_MODE}" != "${NET_CONF_SKIP}" ]
    then
      ask_net_if
    fi
    case "${NET_CONF_MODE}" in
      "${NET_CONF_AUTO}")
        net_conf_auto
        ;;
      "${NET_CONF_WLAN}")
        ask_wlan_data
        net_conf_wlan
        ;;
      "${NET_CONF_MANUAL}")
        ask_net_addr
        net_conf_manual
        ;;
      "${NET_CONF_SKIP}")
        ;;
      *)
        ;;
    esac
    sleep_clear 1
    check_inet_conn
    sleep_clear 1
    self_updater

    # pacman
    sleep_clear 1
    ask_mirror_arch
    sleep_clear 1
    update_pacman
  fi

  # hard drive
  get_hd_devs
  ask_hd_dev
  umount_filesystems "harddrive"
  sleep_clear 1
  ask_cfdisk
  sleep_clear 3
  ask_luks
  get_partition_label
  ask_partitions
  print_partitions
  ask_formatting
  clear
  make_partitions
  clear
  mount_filesystems
  sleep_clear 1

  # arch linux
  pass_mirror_conf
  sleep_clear 1
  setup_base_system
  sleep_clear 1
  setup_time
  sleep_clear 1

  # blackarch Linux
  if [ "${INSTALL_MODE}" != "${INSTALL_LIVE_ISO}" ]
  then
    setup_blackarch
    sleep_clear 1
  fi

  # epilog
  umount_filesystems
  sleep_clear 1
  sync_disk
  sleep_clear 1
  easter_backdoor

  return $SUCCESS
}


# we start here
main "${@}"


# EOF