echo -e "

${COL_LIGHT_GREEN}.;;,.

.ccccc:,.

:cccclll:. ..,,

:ccccclll. ;ooodc

'ccll:;ll .oooodc

.;cll.;;looo:.

${COL_LIGHT_RED}.. ','.

.',,,,,,'.

.',,,,,,,,,,.

.',,,,,,,,,,,,....

....''',,,,,,,'.......

......... .... .........

.......... ..........

.......... ..........

......... .... .........

........,,,,,,,'......

....',,,,,,,,,,,,.

.',,,,,,,,,'.

.',,,,,,'.

..'''.${COL_NC}

"

# Checks for existence of string passed in as only function argument.

# Exit value of 0 when exists, 1 if not exists. Value is the result

# of the `command` shell built-in call.

local check_command="$1"

command -v "${check_command}" >/dev/null 2>&1

# If apt-get is installed, then we know it's part of the Debian family

if is_command apt-get ; then

# Set some global variables here

# We don't set them earlier since the family might be Red Hat, so these values would be different

PKG_MANAGER="apt-get"

# A variable to store the command used to update the package cache

UPDATE_PKG_CACHE="${PKG_MANAGER} update"

# An array for something...

PKG_INSTALL=(${PKG_MANAGER} --yes --no-install-recommends install)

# grep -c will return 1 retVal on 0 matches, block this throwing the set -e with an OR TRUE

PKG_COUNT="${PKG_MANAGER} -s -o Debug::NoLocking=true upgrade | grep -c ^Inst || true"

# Some distros vary slightly so these fixes for dependencies may apply

# on Ubuntu 18.04.1 LTS we need to add the universe repository to gain access to dialog and dhcpcd5

APT_SOURCES="/etc/apt/sources.list"

if awk 'BEGIN{a=1;b=0}/bionic main/{a=0}/bionic.*universe/{b=1}END{exit a + b}' ${APT_SOURCES}; then

if ! whiptail --defaultno --title "Dependencies Require Update to Allowed Repositories" --yesno "Would you like to enable 'universe' repository?\\n\\nThis repository is required by the following packages:\\n\\n- dhcpcd5\\n- dialog" ${r} ${c}; then

printf " %b Aborting installation: dependencies could not be installed.\\n" "${CROSS}"

exit # exit the installer

else

printf " %b Enabling universe package repository for Ubuntu Bionic\\n" "${INFO}"

cp ${APT_SOURCES} ${APT_SOURCES}.backup # Backup current repo list

printf " %b Backed up current configuration to %s\\n" "${TICK}" "${APT_SOURCES}.backup"

add-apt-repository universe

printf " %b Enabled %s\\n" "${TICK}" "'universe' repository"

fi

fi

# Debian 7 doesn't have iproute2 so if the dry run install is successful,

if ${PKG_MANAGER} install --dry-run iproute2 > /dev/null 2>&1; then

# we can install it

iproute_pkg="iproute2"

# Otherwise,

else

# use iproute

iproute_pkg="iproute"

fi

# Check for and determine version number (major and minor) of current php install

if is_command php ; then

printf " %b Existing PHP installation detected : PHP version %s\\n" "${INFO}" "$(php <<< "<?php echo PHP_VERSION ?>")"

printf -v phpInsMajor "%d" "$(php <<< "<?php echo PHP_MAJOR_VERSION ?>")"

printf -v phpInsMinor "%d" "$(php <<< "<?php echo PHP_MINOR_VERSION ?>")"

# Is installed php version 7.0 or greater

if [ "${phpInsMajor}" -ge 7 ]; then

phpInsNewer=true

fi

fi

# Check if installed php is v 7.0, or newer to determine packages to install

if [[ "$phpInsNewer" != true ]]; then

# Prefer the php metapackage if it's there

if ${PKG_MANAGER} install --dry-run php > /dev/null 2>&1; then

phpVer="php"

# fall back on the php5 packages

else

phpVer="php5"

fi

else

# Newer php is installed, its common, cgi & sqlite counterparts are deps

phpVer="php$phpInsMajor.$phpInsMinor"

fi

# We also need the correct version for `php-sqlite` (which differs across distros)

if ${PKG_MANAGER} install --dry-run ${phpVer}-sqlite3 > /dev/null 2>&1; then

phpSqlite="sqlite3"

else

phpSqlite="sqlite"

fi

# Since our install script is so large, we need several other programs to successfully get a machine provisioned

# These programs are stored in an array so they can be looped through later

INSTALLER_DEPS=(apt-utils dialog debconf dhcpcd5 git ${iproute_pkg} whiptail)

# Pi-hole itself has several dependencies that also need to be installed

PIHOLE_DEPS=(cron curl dnsutils iputils-ping lsof netcat psmisc sudo unzip wget idn2 sqlite3 libcap2-bin dns-root-data resolvconf libcap2)

# The Web dashboard has some that also need to be installed

# It's useful to separate the two since our repos are also setup as "Core" code and "Web" code

PIHOLE_WEB_DEPS=(lighttpd ${phpVer}-common ${phpVer}-cgi ${phpVer}-${phpSqlite})

# The Web server user,

LIGHTTPD_USER="www-data"

# group,

LIGHTTPD_GROUP="www-data"

# and config file

LIGHTTPD_CFG="lighttpd.conf.debian"

# A function to check...

test_dpkg_lock() {

# An iterator used for counting loop iterations

i=0

# fuser is a program to show which processes use the named files, sockets, or filesystems

# So while the command is true

while fuser /var/lib/dpkg/lock >/dev/null 2>&1 ; do

# Wait half a second

sleep 0.5

# and increase the iterator

((i=i+1))

done

# Always return success, since we only return if there is no

# lock (anymore)

return 0

}

# If apt-get is not found, check for rpm to see if it's a Red Hat family OS

elif is_command rpm ; then

# Then check if dnf or yum is the package manager

if is_command dnf ; then

PKG_MANAGER="dnf"

else

PKG_MANAGER="yum"

fi

# Fedora and family update cache on every PKG_INSTALL call, no need for a separate update.

UPDATE_PKG_CACHE=":"

PKG_INSTALL=(${PKG_MANAGER} install -y)

PKG_COUNT="${PKG_MANAGER} check-update | egrep '(.i686|.x86|.noarch|.arm|.src)' | wc -l"

INSTALLER_DEPS=(dialog git iproute newt procps-ng which)

PIHOLE_DEPS=(bind-utils cronie curl findutils nmap-ncat sudo unzip wget libidn2 psmisc sqlite libcap)

PIHOLE_WEB_DEPS=(lighttpd lighttpd-fastcgi php-common php-cli php-pdo)

LIGHTTPD_USER="lighttpd"

LIGHTTPD_GROUP="lighttpd"

LIGHTTPD_CFG="lighttpd.conf.fedora"

# If the host OS is Fedora,

if grep -qiE 'fedora|fedberry' /etc/redhat-release; then

# all required packages should be available by default with the latest fedora release

# ensure 'php-json' is installed on Fedora (installed as dependency on CentOS7 + Remi repository)

PIHOLE_WEB_DEPS+=('php-json')

# or if host OS is CentOS,

elif grep -qiE 'centos|scientific' /etc/redhat-release; then

# Pi-Hole currently supports CentOS 7+ with PHP7+

SUPPORTED_CENTOS_VERSION=7

SUPPORTED_CENTOS_PHP_VERSION=7

# Check current CentOS major release version

CURRENT_CENTOS_VERSION=$(grep -oP '(?<= )[0-9]+(?=\.)' /etc/redhat-release)

# Check if CentOS version is supported

if [[ $CURRENT_CENTOS_VERSION -lt $SUPPORTED_CENTOS_VERSION ]]; then

printf " %b CentOS %s is not supported.\\n" "${CROSS}" "${CURRENT_CENTOS_VERSION}"

printf " Please update to CentOS release %s or later.\\n" "${SUPPORTED_CENTOS_VERSION}"

# exit the installer

exit

fi

# on CentOS we need to add the EPEL repository to gain access to Fedora packages

EPEL_PKG="epel-release"

rpm -q ${EPEL_PKG} &> /dev/null || rc=$?

if [[ $rc -ne 0 ]]; then

printf " %b Enabling EPEL package repository (https://fedoraproject.org/wiki/EPEL)\\n" "${INFO}"

"${PKG_INSTALL[@]}" ${EPEL_PKG} &> /dev/null

printf " %b Installed %s\\n" "${TICK}" "${EPEL_PKG}"

fi

# The default php on CentOS 7.x is 5.4 which is EOL

# Check if the version of PHP available via installed repositories is >= to PHP 7

AVAILABLE_PHP_VERSION=$(${PKG_MANAGER} info php | grep -i version | grep -o '[0-9]\+' | head -1)

if [[ $AVAILABLE_PHP_VERSION -ge $SUPPORTED_CENTOS_PHP_VERSION ]]; then

# Since PHP 7 is available by default, install via default PHP package names

: # do nothing as PHP is current

else

REMI_PKG="remi-release"

REMI_REPO="remi-php72"

rpm -q ${REMI_PKG} &> /dev/null || rc=$?

if [[ $rc -ne 0 ]]; then

# The PHP version available via default repositories is older than version 7

if ! whiptail --defaultno --title "PHP 7 Update (recommended)" --yesno "PHP 7.x is recommended for both security and language features.\\nWould you like to install PHP7 via Remi's RPM repository?\\n\\nSee: https://rpms.remirepo.net for more information" ${r} ${c}; then

# User decided to NOT update PHP from REMI, attempt to install the default available PHP version

printf " %b User opt-out of PHP 7 upgrade on CentOS. Deprecated PHP may be in use.\\n" "${INFO}"

: # continue with unsupported php version

else

printf " %b Enabling Remi's RPM repository (https://rpms.remirepo.net)\\n" "${INFO}"

"${PKG_INSTALL[@]}" "https://rpms.remirepo.net/enterprise/${REMI_PKG}-$(rpm -E '%{rhel}').rpm" &> /dev/null

# enable the PHP 7 repository via yum-config-manager (provided by yum-utils)

"${PKG_INSTALL[@]}" "yum-utils" &> /dev/null

yum-config-manager --enable ${REMI_REPO} &> /dev/null

printf " %b Remi's RPM repository has been enabled for PHP7\\n" "${TICK}"

# trigger an install/update of PHP to ensure previous version of PHP is updated from REMI

if "${PKG_INSTALL[@]}" "php-cli" &> /dev/null; then

printf " %b PHP7 installed/updated via Remi's RPM repository\\n" "${TICK}"

else

printf " %b There was a problem updating to PHP7 via Remi's RPM repository\\n" "${CROSS}"

exit 1

fi

fi

fi

fi

else

# Warn user of unsupported version of Fedora or CentOS

if ! whiptail --defaultno --title "Unsupported RPM based distribution" --yesno "Would you like to continue installation on an unsupported RPM based distribution?\\n\\nPlease ensure the following packages have been installed manually:\\n\\n- lighttpd\\n- lighttpd-fastcgi\\n- PHP version 7+" ${r} ${c}; then

printf " %b Aborting installation due to unsupported RPM based distribution\\n" "${CROSS}"

exit # exit the installer

else

printf " %b Continuing installation with unsupported RPM based distribution\\n" "${INFO}"

fi

fi

# If neither apt-get or yum/dnf package managers were found

else

# it's not an OS we can support,

printf " %b OS distribution not supported\\n" "${CROSS}"

# so exit the installer

exit

fi

# Use a named, local variable instead of the vague $1, which is the first argument passed to this function

# These local variables should always be lowercase

local directory="${1}"

# A local variable for the current directory

local curdir

# A variable to store the return code

local rc

# Assign the current directory variable by using pwd

curdir="${PWD}"

# If the first argument passed to this function is a directory,

if [[ -d "${directory}" ]]; then

# move into the directory

cd "${directory}"

# Use git to check if the directory is a repo

# git -C is not used here to support git versions older than 1.8.4

git status --short &> /dev/null || rc=$?

# If the command was not successful,

else

# Set a non-zero return code if directory does not exist

rc=1

fi

# Move back into the directory the user started in

cd "${curdir}"

# Return the code; if one is not set, return 0

return "${rc:-0}"

# Set named variables for better readability

local directory="${1}"

local remoteRepo="${2}"

# The message to display when this function is running

str="Clone ${remoteRepo} into ${directory}"

# Display the message and use the color table to preface the message with an "info" indicator

printf " %b %s..." "${INFO}" "${str}"

# If the directory exists,

if [[ -d "${directory}" ]]; then

# delete everything in it so git can clone into it

rm -rf "${directory}"

fi

# Clone the repo and return the return code from this command

git clone -q --depth 20 "${remoteRepo}" "${directory}" &> /dev/null || return $?

# Show a colored message showing it's status

printf "%b %b %s\\n" "${OVER}" "${TICK}" "${str}"

# Always return 0? Not sure this is correct

return 0

# Use named, local variables

# As you can see, these are the same variable names used in the last function,

# but since they are local, their scope does not go beyond this function

# This helps prevent the wrong value from being assigned if you were to set the variable as a GLOBAL one

local directory="${1}"

local curdir

# A variable to store the message we want to display;

# Again, it's useful to store these in variables in case we need to reuse or change the message;

# we only need to make one change here

local str="Update repo in ${1}"

# Make sure we know what directory we are in so we can move back into it

curdir="${PWD}"

# Move into the directory that was passed as an argument

cd "${directory}" &> /dev/null || return 1

# Let the user know what's happening

printf " %b %s..." "${INFO}" "${str}"

# Stash any local commits as they conflict with our working code

git stash --all --quiet &> /dev/null || true # Okay for stash failure

git clean --quiet --force -d || true # Okay for already clean directory

# Pull the latest commits

git pull --quiet &> /dev/null || return $?

# Show a completion message

printf "%b %b %s\\n" "${OVER}" "${TICK}" "${str}"

# Move back into the original directory

cd "${curdir}" &> /dev/null || return 1

return 0

# Setup named variables for the git repos

# We need the directory

local directory="${1}"

# as well as the repo URL

local remoteRepo="${2}"

# A local variable containing the message to be displayed

local str="Check for existing repository in ${1}"

# Show the message

printf " %b %s..." "${INFO}" "${str}"

# Check if the directory is a repository

if is_repo "${directory}"; then

# Show that we're checking it

printf "%b %b %s\\n" "${OVER}" "${TICK}" "${str}"

# Update the repo, returning an error message on failure

update_repo "${directory}" || { printf "\\n %b: Could not update local repository. Contact support.%b\\n" "${COL_LIGHT_RED}" "${COL_NC}"; exit 1; }

# If it's not a .git repo,

else

# Show an error

printf "%b %b %s\\n" "${OVER}" "${CROSS}" "${str}"

# Attempt to make the repository, showing an error on failure

make_repo "${directory}" "${remoteRepo}" || { printf "\\n %bError: Could not update local repository. Contact support.%b\\n" "${COL_LIGHT_RED}" "${COL_NC}"; exit 1; }

fi

# echo a blank line

echo ""

# and return success?

return 0

# Use named variables for arguments

local directory="${1}"

# Move into the directory

cd "${directory}" &> /dev/null || return 1

# Store the message in a variable

str="Resetting repository within ${1}..."

# Show the message

printf " %b %s..." "${INFO}" "${str}"

# Use git to remove the local changes

git reset --hard &> /dev/null || return $?

# And show the status

printf "%b %b %s\\n" "${OVER}" "${TICK}" "${str}"

# Returning success anyway?

return 0

# Detects IPv4 address used for communication to WAN addresses.

# Accepts no arguments, returns no values.

# Named, local variables

local route

local IPv4bare

# Find IP used to route to outside world by checking the the route to Google's public DNS server

route=$(ip route get 8.8.8.8)

# Get just the interface IPv4 address

# shellcheck disable=SC2059,SC2086

# disabled as we intentionally want to split on whitespace and have printf populate

# the variable with just the first field.

printf -v IPv4bare "$(printf ${route#*src })"

# Get the default gateway IPv4 address (the way to reach the Internet)

# shellcheck disable=SC2059,SC2086

printf -v IPv4gw "$(printf ${route#*via })"

if ! valid_ip "${IPv4bare}" ; then

IPv4bare="127.0.0.1"

fi

# Append the CIDR notation to the IP address, if valid_ip fails this should return 127.0.0.1/8

IPV4_ADDRESS=$(ip -oneline -family inet address show | grep "${IPv4bare}/" | awk '{print $4}' | awk 'END {print}')

# Display the welcome dialog using an appropriately sized window via the calculation conducted earlier in the script

whiptail --msgbox --backtitle "Welcome" --title "Pi-hole automated installer" "\\n\\nThis installer will transform your device into a network-wide ad blocker!" ${r} ${c}

# Request that users donate if they enjoy the software since we all work on it in our free time

whiptail --msgbox --backtitle "Plea" --title "Free and open source" "\\n\\nThe Pi-hole is free, but powered by your donations: http://pi-hole.net/donate" ${r} ${c}

# Explain the need for a static address

whiptail --msgbox --backtitle "Initiating network interface" --title "Static IP Needed" "\\n\\nThe Pi-hole is a SERVER so it needs a STATIC IP ADDRESS to function properly.

In the next section, you can choose to use your current network settings (DHCP) or to manually edit them." ${r} ${c}

# 50MB is the minimum space needed (45MB install (includes web admin bootstrap/jquery libraries etc) + 5MB one day of logs.)

# - Fourdee: Local ensures the variable is only created, and accessible within this function/void. Generally considered a "good" coding practice for non-global variables.

local str="Disk space check"

# Required space in KB

local required_free_kilobytes=51200

# Calculate existing free space on this machine

local existing_free_kilobytes

existing_free_kilobytes=$(df -Pk | grep -m1 '\/$' | awk '{print $4}')

# If the existing space is not an integer,

if ! [[ "${existing_free_kilobytes}" =~ ^([0-9])+$ ]]; then

# show an error that we can't determine the free space

printf " %b %s\\n" "${CROSS}" "${str}"

printf " %b Unknown free disk space! \\n" "${INFO}"

printf " We were unable to determine available free disk space on this system.\\n"

printf " You may override this check, however, it is not recommended.\\n"

printf " The option '%b--i_do_not_follow_recommendations%b' can override this.\\n" "${COL_LIGHT_RED}" "${COL_NC}"

printf " e.g: curl -L https://install.pi-hole.net | bash /dev/stdin %b<option>%b\\n" "${COL_LIGHT_RED}" "${COL_NC}"

# exit with an error code

exit 1

# If there is insufficient free disk space,

elif [[ "${existing_free_kilobytes}" -lt "${required_free_kilobytes}" ]]; then

# show an error message

printf " %b %s\\n" "${CROSS}" "${str}"

printf " %b Your system disk appears to only have %s KB free\\n" "${INFO}" "${existing_free_kilobytes}"

printf " It is recommended to have a minimum of %s KB to run the Pi-hole\\n" "${required_free_kilobytes}"

# if the vcgencmd command exists,

if is_command vcgencmd ; then

# it's probably a Raspbian install, so show a message about expanding the filesystem

printf " If this is a new install you may need to expand your disk\\n"

printf " Run 'sudo raspi-config', and choose the 'expand file system' option\\n"

printf " After rebooting, run this installation again\\n"

printf " e.g: curl -L https://install.pi-hole.net | bash\\n"

fi

# Show there is not enough free space

printf "\\n %bInsufficient free space, exiting...%b\\n" "${COL_LIGHT_RED}" "${COL_NC}"

# and exit with an error

exit 1

# Otherwise,

else

# Show that we're running a disk space check

printf " %b %s\\n" "${TICK}" "${str}"

fi

# Turn the available interfaces into an array so it can be used with a whiptail dialog

local interfacesArray=()

# Number of available interfaces

local interfaceCount

# Whiptail variable storage

local chooseInterfaceCmd

# Temporary Whiptail options storage

local chooseInterfaceOptions

# Loop sentinel variable

local firstLoop=1

# Find out how many interfaces are available to choose from

interfaceCount=$(wc -l <<< "${availableInterfaces}")

# If there is one interface,

if [[ "${interfaceCount}" -eq 1 ]]; then

# Set it as the interface to use since there is no other option

PIHOLE_INTERFACE="${availableInterfaces}"

# Otherwise,

else

# While reading through the available interfaces

while read -r line; do

# use a variable to set the option as OFF to begin with

mode="OFF"

# If it's the first loop,

if [[ "${firstLoop}" -eq 1 ]]; then

# set this as the interface to use (ON)

firstLoop=0

mode="ON"

fi

# Put all these interfaces into an array

interfacesArray+=("${line}" "available" "${mode}")

# Feed the available interfaces into this while loop

done <<< "${availableInterfaces}"

# The whiptail command that will be run, stored in a variable

chooseInterfaceCmd=(whiptail --separate-output --radiolist "Choose An Interface (press space to select)" ${r} ${c} ${interfaceCount})

# Now run the command using the interfaces saved into the array

chooseInterfaceOptions=$("${chooseInterfaceCmd[@]}" "${interfacesArray[@]}" 2>&1 >/dev/tty) || \

# If the user chooses Cancel, exit

{ printf " %bCancel was selected, exiting installer%b\\n" "${COL_LIGHT_RED}" "${COL_NC}"; exit 1; }

# For each interface

for desiredInterface in ${chooseInterfaceOptions}; do

# Set the one the user selected as the interface to use

PIHOLE_INTERFACE=${desiredInterface}

# and show this information to the user

printf " %b Using interface: %s\\n" "${INFO}" "${PIHOLE_INTERFACE}"

done

fi

# first will contain fda2 (ULA)

printf -v first "%s" "${1%%:*}"

# value1 will contain 253 which is the decimal value corresponding to 0xfd

value1=$(( (0x$first)/256 ))

# will contain 162 which is the decimal value corresponding to 0xa2

value2=$(( (0x$first)%256 ))

# the ULA test is testing for fc00::/7 according to RFC 4193

if (( (value1&254)==252 )); then

# echoing result to calling function as return value

echo "ULA"

fi

# the GUA test is testing for 2000::/3 according to RFC 4291

if (( (value1&112)==32 )); then

# echoing result to calling function as return value

echo "GUA"

fi

# the LL test is testing for fe80::/10 according to RFC 4193

if (( (value1)==254 )) && (( (value2&192)==128 )); then

# echoing result to calling function as return value

echo "Link-local"

fi

# Determine the IPv6 address used for blocking

IPV6_ADDRESSES=($(ip -6 address | grep 'scope global' | awk '{print $2}'))

# For each address in the array above, determine the type of IPv6 address it is

for i in "${IPV6_ADDRESSES[@]}"; do

# Check if it's ULA, GUA, or LL by using the function created earlier

result=$(testIPv6 "$i")

# If it's a ULA address, use it and store it as a global variable

[[ "${result}" == "ULA" ]] && ULA_ADDRESS="${i%/*}"

# If it's a GUA address, we can still use it si store it as a global variable

[[ "${result}" == "GUA" ]] && GUA_ADDRESS="${i%/*}"

done

# Determine which address to be used: Prefer ULA over GUA or don't use any if none found

# If the ULA_ADDRESS contains a value,

if [[ ! -z "${ULA_ADDRESS}" ]]; then

# set the IPv6 address to the ULA address

IPV6_ADDRESS="${ULA_ADDRESS}"

# Show this info to the user

printf " %b Found IPv6 ULA address, using it for blocking IPv6 ads\\n" "${INFO}"

# Otherwise, if the GUA_ADDRESS has a value,

elif [[ ! -z "${GUA_ADDRESS}" ]]; then

# Let the user know

printf " %b Found IPv6 GUA address, using it for blocking IPv6 ads\\n" "${INFO}"

# And assign it to the global variable

IPV6_ADDRESS="${GUA_ADDRESS}"

# If none of those work,

else

# explain that IPv6 blocking will not be used

printf " %b Unable to find IPv6 ULA/GUA address, IPv6 adblocking will not be enabled\\n" "${INFO}"

# So set the variable to be empty

IPV6_ADDRESS=""

fi

# If the IPV6_ADDRESS contains a value

if [[ ! -z "${IPV6_ADDRESS}" ]]; then

# Display that IPv6 is supported and will be used

whiptail --msgbox --backtitle "IPv6..." --title "IPv6 Supported" "$IPV6_ADDRESS will be used to block ads." ${r} ${c}

fi

# Named local variables

local useIPv4

local useIPv6

# Let use select IPv4 and/or IPv6 via a checklist

cmd=(whiptail --separate-output --checklist "Select Protocols (press space to select)" ${r} ${c} 2)

# In an array, show the options available:

# IPv4 (on by default)

options=(IPv4 "Block ads over IPv4" on

# or IPv6 (on by default if available)

IPv6 "Block ads over IPv6" on)

# In a variable, show the choices available; exit if Cancel is selected

choices=$("${cmd[@]}" "${options[@]}" 2>&1 >/dev/tty) || { printf " %bCancel was selected, exiting installer%b\\n" "${COL_LIGHT_RED}" "${COL_NC}"; exit 1; }

# For each choice available,

for choice in ${choices}

do

# Set the values to true

case ${choice} in

IPv4 ) useIPv4=true;;

IPv6 ) useIPv6=true;;

esac

done

# If IPv4 is to be used,

if [[ "${useIPv4}" ]]; then

# Run our function to get the information we need

find_IPv4_information

getStaticIPv4Settings

setStaticIPv4

fi

# If IPv6 is to be used,

if [[ "${useIPv6}" ]]; then

# Run our function to get this information

useIPv6dialog

fi

# Echo the information to the user

printf " %b IPv4 address: %s\\n" "${INFO}" "${IPV4_ADDRESS}"

printf " %b IPv6 address: %s\\n" "${INFO}" "${IPV6_ADDRESS}"

# If neither protocol is selected,

if [[ ! "${useIPv4}" ]] && [[ ! "${useIPv6}" ]]; then

# Show an error in red

printf " %bError: Neither IPv4 or IPv6 selected%b\\n" "${COL_LIGHT_RED}" "${COL_NC}"

# and exit with an error

exit 1

fi

# Local, named variables

local ipSettingsCorrect

# Ask if the user wants to use DHCP settings as their static IP

# This is useful for users that are using DHCP reservations; then we can just use the information gathered via our functions

if whiptail --backtitle "Calibrating network interface" --title "Static IP Address" --yesno "Do you want to use your current network settings as a static address?

IP address: ${IPV4_ADDRESS}

Gateway: ${IPv4gw}" ${r} ${c}; then

# If they choose yes, let the user know that the IP address will not be available via DHCP and may cause a conflict.

whiptail --msgbox --backtitle "IP information" --title "FYI: IP Conflict" "It is possible your router could still try to assign this IP to a device, which would cause a conflict. But in most cases the router is smart enough to not do that.

If you are worried, either manually set the address, or modify the DHCP reservation pool so it does not include the IP you want.

It is also possible to use a DHCP reservation, but if you are going to do that, you might as well set a static address." ${r} ${c}

# Nothing else to do since the variables are already set above

else

# Otherwise, we need to ask the user to input their desired settings.

# Start by getting the IPv4 address (pre-filling it with info gathered from DHCP)

# Start a loop to let the user enter their information with the chance to go back and edit it if necessary

until [[ "${ipSettingsCorrect}" = True ]]; do

# Ask for the IPv4 address

IPV4_ADDRESS=$(whiptail --backtitle "Calibrating network interface" --title "IPv4 address" --inputbox "Enter your desired IPv4 address" ${r} ${c} "${IPV4_ADDRESS}" 3>&1 1>&2 2>&3) || \

# Cancelling IPv4 settings window

{ ipSettingsCorrect=False; echo -e " ${COL_LIGHT_RED}Cancel was selected, exiting installer${COL_NC}"; exit 1; }

printf " %b Your static IPv4 address: %s\\n" "${INFO}" "${IPV4_ADDRESS}"

# Ask for the gateway

IPv4gw=$(whiptail --backtitle "Calibrating network interface" --title "IPv4 gateway (router)" --inputbox "Enter your desired IPv4 default gateway" ${r} ${c} "${IPv4gw}" 3>&1 1>&2 2>&3) || \

# Cancelling gateway settings window

{ ipSettingsCorrect=False; echo -e " ${COL_LIGHT_RED}Cancel was selected, exiting installer${COL_NC}"; exit 1; }

printf " %b Your static IPv4 gateway: %s\\n" "${INFO}" "${IPv4gw}"

# Give the user a chance to review their settings before moving on

if whiptail --backtitle "Calibrating network interface" --title "Static IP Address" --yesno "Are these settings correct?

IP address: ${IPV4_ADDRESS}

Gateway: ${IPv4gw}" ${r} ${c}; then

# After that's done, the loop ends and we move on

ipSettingsCorrect=True

else

# If the settings are wrong, the loop continues

ipSettingsCorrect=False

fi

done

# End the if statement for DHCP vs. static

fi

# check if the IP is already in the file

if grep -q "${IPV4_ADDRESS}" /etc/dhcpcd.conf; then

printf " %b Static IP already configured\\n" "${INFO}"

# If it's not,

else

# we can append these lines to dhcpcd.conf to enable a static IP

echo "interface ${PIHOLE_INTERFACE}

static ip_address=${IPV4_ADDRESS}

static routers=${IPv4gw}

static domain_name_servers=127.0.0.1" | tee -a /etc/dhcpcd.conf >/dev/null

# Then use the ip command to immediately set the new address

ip addr replace dev "${PIHOLE_INTERFACE}" "${IPV4_ADDRESS}"

# Also give a warning that the user may need to reboot their system

printf " %b Set IP address to %s \\n You may need to restart after the install is complete\\n" "${TICK}" "${IPV4_ADDRESS%/*}"

fi

# Local, named variables

local IFCFG_FILE

local IPADDR

local CIDR

IFCFG_FILE=$1

printf -v IPADDR "%s" "${IPV4_ADDRESS%%/*}"

# check if the desired IP is already set

if grep -Eq "${IPADDR}(\\b|\\/)" "${IFCFG_FILE}"; then

printf " %b Static IP already configured\\n" "${INFO}"

# Otherwise,

else

# Put the IP in variables without the CIDR notation

printf -v CIDR "%s" "${IPV4_ADDRESS##*/}"

# Backup existing interface configuration:

cp "${IFCFG_FILE}" "${IFCFG_FILE}".pihole.orig

# Build Interface configuration file using the GLOBAL variables we have

{

echo "# Configured via Pi-hole installer"

echo "DEVICE=$PIHOLE_INTERFACE"

echo "BOOTPROTO=none"

echo "ONBOOT=yes"

echo "IPADDR=$IPADDR"

echo "PREFIX=$CIDR"

echo "GATEWAY=$IPv4gw"

echo "DNS1=$PIHOLE_DNS_1"

echo "DNS2=$PIHOLE_DNS_2"

echo "USERCTL=no"

}> "${IFCFG_FILE}"

# Use ip to immediately set the new address

ip addr replace dev "${PIHOLE_INTERFACE}" "${IPV4_ADDRESS}"

# If NetworkMangler command line interface exists and ready to mangle,

if is_command nmcli && nmcli general status &> /dev/null; then

# Tell NetworkManagler to read our new sysconfig file

nmcli con load "${IFCFG_FILE}" > /dev/null

fi

# Show a warning that the user may need to restart

printf " %b Set IP address to %s\\n You may need to restart after the install is complete\\n" "${TICK}" "${IPV4_ADDRESS%%/*}"

fi

# Local, named variables

local IFCFG_FILE

local CONNECTION_NAME

# If a static interface is already configured, we are done.

if [[ -r "/etc/sysconfig/network/ifcfg-${PIHOLE_INTERFACE}" ]]; then

if grep -q '^BOOTPROTO=.static.' "/etc/sysconfig/network/ifcfg-${PIHOLE_INTERFACE}"; then

return 0

fi

fi

# For the Debian family, if dhcpcd.conf exists,

if [[ -f "/etc/dhcpcd.conf" ]]; then

# configure networking via dhcpcd

setDHCPCD

return 0

fi

# If a DHCPCD config file was not found, check for an ifcfg config file based on interface name

if [[ -f "/etc/sysconfig/network-scripts/ifcfg-${PIHOLE_INTERFACE}" ]];then

# If it exists,

IFCFG_FILE=/etc/sysconfig/network-scripts/ifcfg-${PIHOLE_INTERFACE}

setIFCFG "${IFCFG_FILE}"

return 0

fi

# if an ifcfg config does not exists for the interface name, try the connection name via network manager

if is_command nmcli && nmcli general status &> /dev/null; then

CONNECTION_NAME=$(nmcli dev show "${PIHOLE_INTERFACE}" | grep 'GENERAL.CONNECTION' | cut -d: -f2 | sed 's/^System//' | xargs | tr ' ' '_')

if [[ -f "/etc/sysconfig/network-scripts/ifcfg-${CONNECTION_NAME}" ]];then

# If it exists,

IFCFG_FILE=/etc/sysconfig/network-scripts/ifcfg-${CONNECTION_NAME}

setIFCFG "${IFCFG_FILE}"

return 0

fi

fi

# If previous conditions failed, show an error and exit

printf " %b Warning: Unable to locate configuration file to set static IPv4 address\\n" "${INFO}"

exit 1

# Local, named variables

local ip=${1}

local stat=1

# If the IP matches the format xxx.xxx.xxx.xxx,

if [[ "${ip}" =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$ ]]; then

# Save the old Internal Field Separator in a variable

OIFS=$IFS

# and set the new one to a dot (period)

IFS='.'

# Put the IP into an array

ip=(${ip})

# Restore the IFS to what it was

IFS=${OIFS}

## Evaluate each octet by checking if it's less than or equal to 255 (the max for each octet)

[[ "${ip[0]}" -le 255 && "${ip[1]}" -le 255 \

&& "${ip[2]}" -le 255 && "${ip[3]}" -le 255 ]]

# Save the exit code

stat=$?

fi

# Return the exit code

return ${stat}

# Local, named variables

local DNSSettingsCorrect

# In an array, list the available upstream providers

DNSChooseOptions=()

local DNSServerCount=0

# Save the old Internal Field Separator in a variable

OIFS=$IFS

# and set the new one to newline

IFS=$'\n'

# Put the DNS Servers into an array

for DNSServer in ${DNS_SERVERS}

do

DNSName="$(cut -d';' -f1 <<< "${DNSServer}")"

DNSChooseOptions[DNSServerCount]="${DNSName}"

(( DNSServerCount=DNSServerCount+1 ))

DNSChooseOptions[DNSServerCount]=""

(( DNSServerCount=DNSServerCount+1 ))

done

DNSChooseOptions[DNSServerCount]="Custom"

(( DNSServerCount=DNSServerCount+1 ))

DNSChooseOptions[DNSServerCount]=""

# Restore the IFS to what it was

IFS=${OIFS}

# In a whiptail dialog, show the options

DNSchoices=$(whiptail --separate-output --menu "Select Upstream DNS Provider. To use your own, select Custom." ${r} ${c} 7 \

"${DNSChooseOptions[@]}" 2>&1 >/dev/tty) || \

# exit if Cancel is selected

{ printf " %bCancel was selected, exiting installer%b\\n" "${COL_LIGHT_RED}" "${COL_NC}"; exit 1; }

# Display the selection

printf " %b Using " "${INFO}"

# Depending on the user's choice, set the GLOBAl variables to the IP of the respective provider

if [[ "${DNSchoices}" == "Custom" ]]

then

# Until the DNS settings are selected,

until [[ "${DNSSettingsCorrect}" = True ]]; do

#

strInvalid="Invalid"

# If the first

if [[ ! "${PIHOLE_DNS_1}" ]]; then

# and second upstream servers do not exist

if [[ ! "${PIHOLE_DNS_2}" ]]; then

prePopulate=""

# Otherwise,

else

prePopulate=", ${PIHOLE_DNS_2}"

fi

elif [[ "${PIHOLE_DNS_1}" ]] && [[ ! "${PIHOLE_DNS_2}" ]]; then

prePopulate="${PIHOLE_DNS_1}"

elif [[ "${PIHOLE_DNS_1}" ]] && [[ "${PIHOLE_DNS_2}" ]]; then

prePopulate="${PIHOLE_DNS_1}, ${PIHOLE_DNS_2}"

fi

# Dialog for the user to enter custom upstream servers

piholeDNS=$(whiptail --backtitle "Specify Upstream DNS Provider(s)" --inputbox "Enter your desired upstream DNS provider(s), separated by a comma.\\n\\nFor example '8.8.8.8, 8.8.4.4'" ${r} ${c} "${prePopulate}" 3>&1 1>&2 2>&3) || \

{ printf " %bCancel was selected, exiting installer%b\\n" "${COL_LIGHT_RED}" "${COL_NC}"; exit 1; }

# Clean user input and replace whitespace with comma.