chroot-install

#!/bin/bash
################################################################################
#                                                                              #
# blackarchinstall - Blackarch Install                                         #
#                                                                              #
# FILE                                                                         #
# chroot-install                                                               #
#                                                                              #
# DATE                                                                         #
# 2013-12-16                                                                   #
#                                                                              #
# DESCRIPTION                                                                  #
# Script for easy install                                                      #
#                                                                              #
# AUTHOR                                                                       #
# nrz@nullsecurity.net                                                         #
#                                                                              #
# CONTRIBUTORS                                                                 #
# pierre@pi3rrot.net                                                           #
# noptrix@nullsecurity.net                                                     #
#                                                                              #
################################################################################


# true / false
FALSE="0"
TRUE="1"

# return codes
SUCCESS=1337
FAILURE=31337

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

# blackarch-install version
VERSION="v0.7.8"

# colors
WHITE="$(tput bold ; tput setaf 7)"
GREEN="$(tput setaf 2)"
RED="$(tput bold; tput setaf 1)"
YELLOW="$(tput bold ; tput setaf 3)"
NC="$(tput sgr0)" # No Color

# BA REPO DEFAULT
BLACKARCH_REPO_URL='http://www.blackarch.org/blackarch/$repo/os/$arch'

# luks global variable
LUKS="false"


# printf white
wprintf()
{
    fmt="${1}"

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

    return $SUCCESS
}


# print warning
warn()
{
    fmt="${1}"

    shift
    printf "%s[!] WARNING: ${fmt}%s\n" "${RED}" "${@}" "${NC}"

    return $SUCCESS
}


# print error and exit
err()
{
    fmt="${1}"

    shift
    printf "%s[-] ERROR: ${fmt}%s\n" "${RED}" "${@}" "${NC}"

    return $FAILURE
}


# print error and exit
cri()
{
    fmt=${1}
    shift
    printf "%s[-] CRITICAL: ${fmt}%s\n" "${RED}" "${@}" "${NC}"

    exit $FAILURE
}


# leet banner, very important
banner()
{
    printf "%s--==[ blackarch-install %s ]==--%s\n" \
        "${YELLOW}" "${VERSION}" "${NC}"

    return $SUCCESS
}


# print banner + head
header()
{
    head="${@}"

    clear
    printf '%*s\n' "${COLUMNS:-$(tput cols)}" '' | tr ' ' -
    banner
    printf '%*s\n\n\n' "${COLUMNS:-$(tput cols)}" '' | tr ' ' -
    wprintf ">> %s\n\n" "${head}"

    return $SUCCESS
}


# usage and help
usage()
{
    cat << EOF
usage: $0 <arg> | <misc>
options:
    -l: live-iso install
    -r: repository install
    -b: blackman install
    -d: device target [/dev/sda]
misc:
    -V: print version and exit
    -H: print help and exit
EOF

    exit $SUCCESS
}


# check environment
check_env()
{
    if [ -f /var/lib/pacman/db.lck ]
    then
        cri "pacman locked - rm /var/lib/pacman/db.lck"
    fi
}


# select blackarch repository
select_ba_repo()
{
    mirror_file="/tmp/mirror.lst"
    github_url="https://github.com/BlackArch/blackarch/raw/master/mirror/mirror.lst"

    wprintf "[*] fetching mirror list"
    # check if wget installed
    command -v wget >/dev/null 2>&1 || pacman -S wget --noconfirm
    wget -q "${github_url}" -O "${mirror_file}"
    if [ "${?}" != "0" ]
    then
        err "wget failed - setting BlackArch repository"
        return $FAILURE
    fi

    count="1"
    local IFS='|'
    ( while read -r country url mirror_name; do
        wprintf "   %s. %s - %s" "${count}" "${country}" "${mirror_name}"
        wprintf "       * %s" "${url}"
        ((count++))
    done < "${mirror_file}" )

    printf "%s[?] select mirror number: " "${WHITE}"; read a

    if [ "${a}" -gt "$(wc -l < ${mirror_file})" ]
    then
        # BLACKARCH_REPO_URL gets the default one - choose better next time ;)
        wprintf "[*] you fucked up man - we select BlackArch for you..."
    else
        BLACKARCH_REPO_URL=$(sed -n "${a}p" "${mirror_file}"|cut -d"|" -f2)
        wprintf "   -> mirror from '%s' selected" \
            "$(sed -n "${a}p" "${mirror_file}"|cut -d"|" -f3)"
    fi

    # cleaning up
    rm -rf "${mirror_file}"

    return $SUCCESS
}


# update the system
update_system()
{
    wprintf "[*] adding BlackArch repository"

    select_ba_repo
    if [ "${?}" = "$FAILURE" ]
    then
        warn "mirror selection failed - we go with default one"
    fi

    curl -s http://blackarch.org/strap.sh | sh

    if ! grep -q "blackarch" /etc/pacman.conf
    then
        printf '[blackarch]\nServer = %s\n' "${BLACKARCH_REPO_URL}" \
            >> /etc/pacman.conf
    else
        sed -i "/\[blackarch\]/{ n;s?Server.*?Server = ${BLACKARCH_REPO_URL}?; }" /etc/pacman.conf
    fi

    pacman -Syyu --noconfirm

    return $SUCCESS
}


# testing
install_packages_blackman()
{
    command -v git >/dev/null 2>&1 || pacman -S git --noconfirm

    cd /usr/share/
    git clone https://github.com/nrzizrn/blackman
    ln -s /usr/share/blackman/blackman /usr/bin
    blackman -a

    return $SUCCESS
}


# install blackarch packages
install_packages_repo()
{
    # repo
    pacman -S blackarch

    # X11 related, wms, configs
    pacman -S blackarch-config-awesome blackarch-config-fluxbox \
      blackarch-config-lxdm blackarch-config-openbox fluxbox openbox awesome \
      spectrwm blackarch-dwm i3-wm wmii

    return $SUCCESS
}


# install grub bootloader
install_grub()
{
    pacman -S grub --noconfirm --needed

    mv /boot/splash.png /boot/grub/

    sed -i 's/Arch Linux/BlackArch Linux/' /boot/grub/grub.cfg

    printf 'GRUB_BACKGROUND="/boot/grub/splash.png"\n' >> /etc/default/grub

    if [ "${LUKS}" == "true" ]
    then
        sed -i "s|quiet|cryptdevice=${ROOT_PART}:cryptroot root=/dev/mapper/cryptroot|" /etc/default/grub
        sed -i 's|"Arch"|"BlackArch"|' /etc/default/grub
        #sed -i "s|rw  quiet|rw cryptdevice=${ROOT_PART}:cryptroot|" \
        #  /boot/grub/grub.cfg
    fi

    grub-install --target=i386-pc "${HD}"
    grub-mkconfig -o /boot/grub/grub.cfg

    return $SUCCESS
}


# set passwd check
set_passwd()
{
    user="${1}"

    if [ -n "${user}" ]
    then
        passwd "${user}"
    else
        passwd
    fi

    if [ "${?}" != "0" ]
    then
        wprintf "wrong passwd - please try again"
        set_passwd "${user}"
    else
        return $SUCCESS
    fi

    return $SUCCESS
}


# add and configure users
configure_users()
{
    printf "%s" "${WHITE}"

    printf "[*] setting up root password\n"
    set_passwd

    mv /mnt/shell/root/.bashrc /root/
    cp /root/.bashrc /root/.bash_profile

    printf "[?] setup a normal user account [y/N]: "; read a
    if [ "${a}" == "y" ] || [ "${a}" == "Y" ]
    then
        printf "[?] user name: "; read user
        useradd -m -p "" -g users \
            -G "adm,audio,floppy,log,network,rfkill,scanner,storage,optical,power,wheel" \
            -s /bin/bash "${user}" && printf "[*] user '%s' created\n" "${user}"
        set_passwd "${user}"
        mv /mnt/shell/user/.bashrc "/home/${user}/"
        cp "/home/${user}/.bashrc" "/home/${user}/.bash_profile"
        chown -R "${user}:users" "/home/${user}"
    fi

    # cleaning up
    rm -rf /tmp/shell

    printf "%s" "${NC}"

    return $SUCCESS
}


# not used atm
generate_initramfs()
{
    sed -i 's/block filesystems/block encrypt filesystems/' /etc/mkinitcpio.conf

    mkinitcpio -p linux

    return $SUCCESS
}


# set system hostname
set_hostname()
{

    printf "%s" "${WHITE}"

    printf "[?] set hostname [blackarch]: "
    read hostname

    if [ "${hostname}" == "" ]
    then
        hostname="blackarch"
    fi

    printf "%s\n" "${hostname}" > /etc/hostname

    printf "%s" "${NC}"

    return $SUCCESS
}


# configure X related things
#configure_X()
#{
    # enable display manager
    #systemctl enable lxdm

    # WMs
    #cp -r /usr/share/fluxbox-blackarch/* /usr/share/fluxbox
    #cp /etc/xdg/awesome/rc.lua.blackarch /etc/xdg/awesome/rc.lua
    #cp -r /etc/xdg/openbox-blackarch/* /etc/xdg/openbox
    #cp /usr/share/themes/blackarch/openbox-3-blackarch/* \
    #    /usr/share/themes/blackarch/openbox-3


    #return $SUCCESS
#}


# install the system
install()
{
    menu_opt=${1}

    header "package installation"

    case "${menu_opt}" in
        "live")
            header "system update"
            update_system
            ;;
        "repository")
            header "system update"
            update_system
            install_packages_repo
            ;;
        "blackman")
            install_packages_blackman
            ;;
    esac

    header "user configuration"
    configure_users

    header "initramfs"
    "${LUKS}" && generate_initramfs

    header "hostname setup"
    set_hostname

    # set keymaps choosed before silently
    printf "KEYMAP=%s\n" "${KEYMAPS}" > /etc/vconsole.conf

    #header "X configuration"
    #configure_X

    header "grub installation"
    install_grub

    # sync hd
    sync

    printf "%s[*] BlackArch Linux ready! Enjoy!%s\n" "${RED}" "${NC}"

    return $SUCCESS
}


# parse command line options
get_opts()
{
    while getopts lrbD:R:Lk:vVH flags
    do
        case "${flags}" in
            l)
                opt_arg="live"
                ;;
            r)
                opt_arg="repository"
                ;;
            b)
                opt_arg="blackman"
                ;;
            D)
                HD=${OPTARG}
                ;;
            R)
                ROOT_PART=${OPTARG}
                ;;
            L)
                LUKS="true"
                ;;
            k)
                KEYMAPS=${OPTARG}
                ;;
            v)
                VERBOSE="/dev/stdout"
                ;;
            V)
                printf "%s\n" "${VERSION}"
                exit $SUCCESS
                ;;
            H)
                usage
                ;;
            *)
                err "WTF?! mount /dev/brain"
                ;;
        esac
    done

    return $SUCCESS
}


# controller and program flow
main()
{
    get_opts "${@}"
    check_env
    install "${opt_arg}"

    return $SUCCESS
}


# program start
main "${@}"

# EOF