#!/bin/bash

####################################################################################################
#### author: SlickStack ############################################################################
#### link: https://slickstack.io ###################################################################
#### mirror: http://mirrors.slickstack.io/bash/ss-update-config.txt ################################
#### path: /var/www/ss-update-config ###############################################################
#### destination: n/a (not a boilerplate) ##########################################################
#### purpose: Updates ss-config file to latest boilerplate version and transfers settings ##########
#### module version: Ubuntu 20.04 LTS ##############################################################
#### sourced by: ss core cron jobs #################################################################
#### bash aliases: ss update config, ss upgrade config #############################################
####################################################################################################

## YOU CAN SAFELY RUN SS-UPDATE WITH NO CHANGES TO YOUR LEMP MODULE CONFIGURATION FILES ##
## IN CASE YOU ACCIDENTALLY OVERWRITE CONFIG FILES, SIMPLY RUN SS-INSTALL AGAIN ##

## include SlickStack configuration ##
source /var/www/ss-config

## include SlickStack functions ##
source /var/www/ss-functions

## script variables ##
SS_UPDATE_BUILD="FEB2021J"
VALIDATE_SS_CONFIG=$(grep 'EOF' "$PATH_SS_CONFIG") ## change to "$SS_EOF" later

####################################################################################################
#### SS-Update: Message (Begin Script) #############################################################
####################################################################################################

## this is a simple message that announces to the shell the purpose of this bash script ##
## it will only be noticed by sudo users who manually call ss core bash scripts ##

## echo message ##
echo -e "${PURPLE}Running ss-update-config: Updates ss-config file to latest boilerplate version and transfers settings... ${NOCOLOR}"
sleep "$SLEEP_MESSAGE_BEGIN"

####################################################################################################
#### SS-Update-Config: Cleanup Temporary Files #####################################################
####################################################################################################

## delete tmp files ##
rm "$TMP_SS_CONFIG"

####################################################################################################
#### SS-Update-Config: Backup Current SS-Config File ###############################################
####################################################################################################

## SNIPPET: ss-worker, ss-update-config

## this snippet will duplicate your live ss-config file to the /var/www/meta/ folder ##
## the timestamped .bak files will be cleaned up periodically by ss-clean ##

## backup ss-config ##
current_time=$(date "+%Y.%b.%d-%H:%M:%S")
cp "$PATH_SS_CONFIG" /var/www/meta/ss-config.bak.$current_time

####################################################################################################
#### SS-Update: Ensure Undefined Options Do Not Exist Before Proceeding ############################
####################################################################################################

## below snippet will warn you and exit if undefined ss-config options are found to exist ##
## this way our team can be aware of bugs and avoid implementing unwanted options ##

## validate ss-config ##
if [[ -z "$VALIDATE_SS_CONFIG" ]]; then
    echo -e "${DARKRED}Exiting ss-update-config: Your current ss-config file is missing or corrupt so update was skipped... ${NOCOLOR}"
    exit 1
fi

## warn if placeholders exist ##
SS_CONFIG_OPTION_PLACEHOLDER="$(grep -c '"@' /var/www/ss-config)"
if [[ "$SS_CONFIG_OPTION_PLACEHOLDER" -gt 0 ]]; then
    echo -e "${DARKRED}Exiting ss-update-config: Please replace all \"@...\" placeholders in your ss-config and try again... ${NOCOLOR}"
    exit 1
fi

####################################################################################################
#### SS-Update-Config: Install Latest SS-Config Boilerplate (Replicates Existing Variables) ###############
####################################################################################################

## variables will only be copied over from the previous ss-config file if they are defined ##
## otherwise default (recommended) options will be used from the new boilerplate ##

## retrieve latest version of ss-config-sample ##
wget -O "$TMP_SS_CONFIG" "$MIRROR_SS_CONFIG_SAMPLE"

## ensure latest (retrieved) ss-config build matches current ss-update build ##
SS_BUILD_LATEST=$(source /tmp/ss-config; echo $SS_BUILD)
if [[ "$SS_BUILD_LATEST" != "$SS_UPDATE_BUILD" ]]; then
    rm "$TMP_SS_CONFIG"
    echo -e "${LIGHTRED}Exiting ss-update-config: Please update this script by running ss-check and then run it again... ${NOCOLOR}"
    exit 1
fi

####################################################################################################
#### SS-Update: Install Latest SS-Config File (Safely Replicates Existing Variables) ###############
####################################################################################################

## copy over shell settings ##
sed -i "s|\(^ROOT_PASSWORD=\).*|ROOT_PASSWORD=\"$ROOT_PASSWORD\"|g" "$TMP_SS_CONFIG"
sed -i "s|\(^SUDO_USER=\).*|SUDO_USER=\"$SUDO_USER\"|g" "$TMP_SS_CONFIG"
sed -i "s|\(^SUDO_PASSWORD=\).*|SUDO_PASSWORD=\"$SUDO_PASSWORD\"|g" "$TMP_SS_CONFIG"
sed -i "s|\(^SSH_PORT=\).*|SSH_PORT=\"$SSH_PORT\"|g" "$TMP_SS_CONFIG"
sed -i "s|\(^SSH_KEYS=\).*|SSH_KEYS=\"$SSH_KEYS\"|g" "$TMP_SS_CONFIG"
sed -i "s|\(^SFTP_USER=\).*|SFTP_USER=\"$SFTP_USER\"|g" "$TMP_SS_CONFIG"
sed -i "s|\(^SFTP_PASSWORD=\).*|SFTP_PASSWORD=\"$SFTP_PASSWORD\"|g" "$TMP_SS_CONFIG"

## copy over initial database settings ##
sed -i "s|\(^DB_NAME=\).*|DB_NAME=\"$DB_NAME\"|g" "$TMP_SS_CONFIG"
sed -i "s|\(^DB_USER=\).*|DB_USER=\"$DB_USER\"|g" "$TMP_SS_CONFIG"
sed -i "s|\(^DB_PASSWORD=\).*|DB_PASSWORD=\"$DB_PASSWORD\"|g" "$TMP_SS_CONFIG"
sed -i "s|\(^DB_PASSWORD_ROOT=\).*|DB_PASSWORD_ROOT=\"$DB_PASSWORD_ROOT\"|g" "$TMP_SS_CONFIG"

## only copy over remote DB_HOST otherwise use new default 127.0.0.1 (present in the default new template) ##
## also preserves localhost if some devs prefer over TCP ##
# if [[ "$DB_HOST" != "localhost" ]] && [[ "$DB_HOST" != "127.0.0.1" ]] && [[ "$DB_HOST" != "@DB_HOST" ]]; then
if [[ -n "$DB_HOST" ]]; then 
    sed -i "s|\(^DB_HOST=\).*|DB_HOST=\"$DB_HOST\"|g" "$TMP_SS_CONFIG"
    ## cleanup in case old/default ##
    sed -i "s#localhost#127.0.0.1#g" "$TMP_SS_CONFIG"
    sed -i "s#@DB_HOST#127.0.0.1#g" "$TMP_SS_CONFIG"
fi

## copy over remaining database settings ##
sed -i "s|\(^DB_PREFIX=\).*|DB_PREFIX=\"$DB_PREFIX\"|g" "$TMP_SS_CONFIG"
sed -i "s|\(^DB_CHARSET=\).*|DB_CHARSET=\"$DB_CHARSET\"|g" "$TMP_SS_CONFIG"
sed -i "s|\(^DB_COLLATE=\).*|DB_COLLATE=\"$DB_COLLATE\"|g" "$TMP_SS_CONFIG"

## copy over site settings ##
sed -i "s|\(^SITE_TLD=\).*|SITE_TLD=\"$SITE_TLD\"|g" "$TMP_SS_CONFIG"
sed -i "s|\(^SITE_DOMAIN=\).*|SITE_DOMAIN=\"$SITE_DOMAIN\"|g" "$TMP_SS_CONFIG"
sed -i "s|\(^SITE_NOINDEX=\).*|SITE_NOINDEX=\"$SITE_NOINDEX\"|g" "$TMP_SS_CONFIG"

## copy over Multisite settings ##
if [[ -n "$WP_MULTISITE" ]]; then 
sed -i "s|\(^WP_MULTISITE=\).*|WP_MULTISITE=\"$WP_MULTISITE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$WP_MULTISITE_SUBDOMAINS" ]]; then 
sed -i "s|\(^WP_MULTISITE_SUBDOMAINS=\).*|WP_MULTISITE_SUBDOMAINS=\"$WP_MULTISITE_SUBDOMAINS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$WP_MULTISITE_DOMAIN_MAPPING" ]]; then 
sed -i "s|\(^WP_MULTISITE_DOMAIN_MAPPING=\).*|WP_MULTISITE_DOMAIN_MAPPING=\"$WP_MULTISITE_DOMAIN_MAPPING\"|g" "$TMP_SS_CONFIG"
fi

## copy over CloudFlare settings ##
sed -i "s|\(^CLOUDFLARE_API_KEY=\).*|CLOUDFLARE_API_KEY=\"$CLOUDFLARE_API_KEY\"|g" "$TMP_SS_CONFIG"
sed -i "s|\(^CLOUDFLARE_API_EMAIL=\).*|CLOUDFLARE_API_EMAIL=\"$CLOUDFLARE_API_EMAIL\"|g" "$TMP_SS_CONFIG"

if [[ -n "$CLOUDFLARE_WIDGET_DNS" ]]; then 
sed -i "s|\(^CLOUDFLARE_WIDGET_DNS=\).*|CLOUDFLARE_WIDGET_DNS=\"$CLOUDFLARE_WIDGET_DNS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$CLOUDFLARE_WIDGET_ANALYTICS" ]]; then 
sed -i "s|\(^CLOUDFLARE_WIDGET_ANALYTICS=\).*|CLOUDFLARE_WIDGET_ANALYTICS=\"$CLOUDFLARE_WIDGET_ANALYTICS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$CLOUDFLARE_RECOMMENDED_SETTINGS" ]]; then 
sed -i "s|\(^CLOUDFLARE_RECOMMENDED_SETTINGS=\).*|CLOUDFLARE_RECOMMENDED_SETTINGS=\"$CLOUDFLARE_RECOMMENDED_SETTINGS\"|g" "$TMP_SS_CONFIG"
fi



################################## ADVANCED SETTINGS ###############################


## copy staging site settings ##
if [[ -n "$STAGING_SITE" ]]; then 
sed -i "s|\(^STAGING_SITE=\).*|STAGING_SITE=\"$STAGING_SITE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$STAGING_SITE_SUBDOMAIN" ]]; then 
sed -i "s|\(^STAGING_SITE_SUBDOMAIN=\).*|STAGING_SITE_SUBDOMAIN=\"$STAGING_SITE_SUBDOMAIN\"|g" "$TMP_SS_CONFIG"
fi


## copy dev site settings ##
if [[ -n "$DEV_SITE" ]]; then 
sed -i "s|\(^DEV_SITE=\).*|DEV_SITE=\"$DEV_SITE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$DEV_SITE_SUBDOMAIN" ]]; then 
sed -i "s|\(^DEV_SITE_SUBDOMAIN=\).*|DEV_SITE_SUBDOMAIN=\"$DEV_SITE_SUBDOMAIN\"|g" "$TMP_SS_CONFIG"
fi


## WP CRON WP-CRON ##
if [[ -n "$WP_CRON_METHOD" ]]; then 
sed -i "s|\(^WP_CRON_METHOD=\).*|WP_CRON_METHOD=\"$WP_CRON_METHOD\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$WP_CRON_INTERVAL" ]]; then 
sed -i "s|\(^WP_CRON_INTERVAL=\).*|WP_CRON_INTERVAL=\"$WP_CRON_INTERVAL\"|g" "$TMP_SS_CONFIG"
fi



## copy over WP config settings ##
if [[ -n "$WP_POST_REVISIONS" ]]; then 
sed -i "s|\(^WP_POST_REVISIONS=\).*|WP_POST_REVISIONS=\"$WP_POST_REVISIONS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$WP_AUTOSAVE_INTERVAL" ]]; then 
sed -i "s|\(^WP_AUTOSAVE_INTERVAL=\).*|WP_AUTOSAVE_INTERVAL=\"$WP_AUTOSAVE_INTERVAL\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$WP_HTTP_BLOCK_EXTERNAL" ]]; then 
sed -i "s|\(^WP_HTTP_BLOCK_EXTERNAL=\).*|WP_HTTP_BLOCK_EXTERNAL=\"$WP_HTTP_BLOCK_EXTERNAL\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$WP_ACCESSIBLE_HOSTS" ]]; then 
sed -i "s|\(^WP_ACCESSIBLE_HOSTS=\).*|WP_ACCESSIBLE_HOSTS=\"$WP_ACCESSIBLE_HOSTS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$WP_DISALLOW_FILE_EDIT" ]]; then 
sed -i "s|\(^WP_DISALLOW_FILE_EDIT=\).*|WP_DISALLOW_FILE_EDIT=\"$WP_DISALLOW_FILE_EDIT\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$WP_DISALLOW_FILE_MODS" ]]; then
sed -i "s|\(^WP_DISALLOW_FILE_MODS=\).*|WP_DISALLOW_FILE_MODS=\"$WP_DISALLOW_FILE_MODS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$WP_ALLOW_UNFILTERED_UPLOADS" ]]; then
sed -i "s|\(^WP_ALLOW_UNFILTERED_UPLOADS=\).*|WP_ALLOW_UNFILTERED_UPLOADS=\"$WP_ALLOW_UNFILTERED_UPLOADS\"|g" "$TMP_SS_CONFIG"
fi

## copy over ssl settings ##
if [[ -n "$SSL_TYPE" ]]; then 
sed -i "s|\(^SSL_TYPE=\).*|SSL_TYPE=\"$SSL_TYPE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SSL_PROTOCOLS" ]]; then 
sed -i "s|\(^SSL_PROTOCOLS=\).*|SSL_PROTOCOLS=\"$SSL_PROTOCOLS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SSL_CIPHERS" ]]; then 
sed -i "s|\(^SSL_CIPHERS=\).*|SSL_CIPHERS=\"$SSL_CIPHERS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SSL_SESSION_TIMEOUT" ]]; then
sed -i "s|\(^SSL_SESSION_TIMEOUT=\).*|SSL_SESSION_TIMEOUT=\"$SSL_SESSION_TIMEOUT\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SSL_SESSION_CACHE" ]]; then
sed -i "s|\(^SSL_SESSION_CACHE=\).*|SSL_SESSION_CACHE=\"$SSL_SESSION_CACHE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SSL_BUFFER_SIZE" ]]; then
sed -i "s|\(^SSL_BUFFER_SIZE=\).*|SSL_BUFFER_SIZE=\"$SSL_BUFFER_SIZE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SSL_EMAIL" ]]; then
sed -i "s|\(^SSL_EMAIL=\).*|SSL_EMAIL=\"$SSL_EMAIL\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SSL_EMAIL_ALERTS" ]]; then
sed -i "s|\(^SSL_EMAIL_ALERTS=\).*|SSL_EMAIL_ALERTS=\"$SSL_EMAIL_ALERTS\"|g" "$TMP_SS_CONFIG"
fi


## copy over csr settings ##
sed -i "s|\(^CSR_COUNTRY=\).*|CSR_COUNTRY=\"$CSR_COUNTRY\"|g" "$TMP_SS_CONFIG"
sed -i "s|\(^CSR_STATE=\).*|CSR_STATE=\"$CSR_STATE\"|g" "$TMP_SS_CONFIG"
sed -i "s|\(^CSR_CITY=\).*|CSR_CITY=\"$CSR_CITY\"|g" "$TMP_SS_CONFIG"
sed -i "s|\(^CSR_COMPANY=\).*|CSR_COMPANY=\"$CSR_COMPANY\"|g" "$TMP_SS_CONFIG"
sed -i "s|\(^CSR_DEPT=\).*|CSR_DEPT=\"$CSR_DEPT\"|g" "$TMP_SS_CONFIG"

## copy over nginx settings ##
if [[ -n "$NGINX_WORKER_RLIMIT_NOFILE" ]]; then
sed -i "s|\(^NGINX_WORKER_RLIMIT_NOFILE=\).*|NGINX_WORKER_RLIMIT_NOFILE=\"$NGINX_WORKER_RLIMIT_NOFILE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$NGINX_WORKER_CONNECTIONS" ]]; then
sed -i "s|\(^NGINX_WORKER_CONNECTIONS=\).*|NGINX_WORKER_CONNECTIONS=\"$NGINX_WORKER_CONNECTIONS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$NGINX_SERVER_NAMES_HASH_BUCKET_SIZE" ]]; then
sed -i "s|\(^NGINX_SERVER_NAMES_HASH_BUCKET_SIZE=\).*|NGINX_SERVER_NAMES_HASH_BUCKET_SIZE=\"$NGINX_SERVER_NAMES_HASH_BUCKET_SIZE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$NGINX_SERVER_NAMES_MAX_HASH_SIZE" ]]; then
sed -i "s|\(^NGINX_SERVER_NAMES_MAX_HASH_SIZE=\).*|NGINX_SERVER_NAMES_MAX_HASH_SIZE=\"$NGINX_SERVER_NAMES_MAX_HASH_SIZE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$NGINX_TYPES_MAX_HASH_SIZE" ]]; then
sed -i "s|\(^NGINX_TYPES_MAX_HASH_SIZE=\).*|NGINX_TYPES_MAX_HASH_SIZE=\"$NGINX_TYPES_MAX_HASH_SIZE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$NGINX_CLIENT_MAX_BODY_SIZE" ]]; then
sed -i "s|\(^NGINX_CLIENT_MAX_BODY_SIZE=\).*|NGINX_CLIENT_MAX_BODY_SIZE=\"$NGINX_CLIENT_MAX_BODY_SIZE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$NGINX_CLIENT_BODY_BUFFER_SIZE" ]]; then
sed -i "s|\(^NGINX_CLIENT_BODY_BUFFER_SIZE=\).*|NGINX_CLIENT_BODY_BUFFER_SIZE=\"$NGINX_CLIENT_BODY_BUFFER_SIZE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$NGINX_CLIENT_HEADER_BUFFER_SIZE" ]]; then
sed -i "s|\(^NGINX_CLIENT_HEADER_BUFFER_SIZE=\).*|NGINX_CLIENT_HEADER_BUFFER_SIZE=\"$NGINX_CLIENT_HEADER_BUFFER_SIZE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$NGINX_LARGE_CLIENT_HEADER_BUFFERS" ]]; then
sed -i "s|\(^NGINX_LARGE_CLIENT_HEADER_BUFFERS=\).*|NGINX_LARGE_CLIENT_HEADER_BUFFERS=\"$NGINX_LARGE_CLIENT_HEADER_BUFFERS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$NGINX_CLIENT_BODY_TIMEOUT" ]]; then
sed -i "s|\(^NGINX_CLIENT_BODY_TIMEOUT=\).*|NGINX_CLIENT_BODY_TIMEOUT=\"$NGINX_CLIENT_BODY_TIMEOUT\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$NGINX_CLIENT_HEADER_TIMEOUT" ]]; then
sed -i "s|\(^NGINX_CLIENT_HEADER_TIMEOUT=\).*|NGINX_CLIENT_HEADER_TIMEOUT=\"$NGINX_CLIENT_HEADER_TIMEOUT\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$NGINX_KEEPALIVE_TIMEOUT" ]]; then
sed -i "s|\(^NGINX_KEEPALIVE_TIMEOUT=\).*|NGINX_KEEPALIVE_TIMEOUT=\"$NGINX_KEEPALIVE_TIMEOUT\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$NGINX_KEEPALIVE_REQUESTS" ]]; then
sed -i "s|\(^NGINX_KEEPALIVE_REQUESTS=\).*|NGINX_KEEPALIVE_REQUESTS=\"$NGINX_KEEPALIVE_REQUESTS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$NGINX_SEND_TIMEOUT" ]]; then
sed -i "s|\(^NGINX_SEND_TIMEOUT=\).*|NGINX_SEND_TIMEOUT=\"$NGINX_SEND_TIMEOUT\"|g" "$TMP_SS_CONFIG"
fi


## nginx headers ##

if [[ -n "$NGINX_HEADER_POWERED_BY" ]]; then
sed -i "s|\(^NGINX_HEADER_POWERED_BY=\).*|NGINX_HEADER_POWERED_BY=\"$NGINX_HEADER_POWERED_BY\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$NGINX_HEADER_STRICT_TRANSPORT_SECURITY" ]]; then
sed -i "s|\(^NGINX_HEADER_STRICT_TRANSPORT_SECURITY=\).*|NGINX_HEADER_STRICT_TRANSPORT_SECURITY=\"$NGINX_HEADER_STRICT_TRANSPORT_SECURITY\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$NGINX_HEADER_REFERRER_POLICY" ]]; then
sed -i "s|\(^NGINX_HEADER_REFERRER_POLICY=\).*|NGINX_HEADER_REFERRER_POLICY=\"$NGINX_HEADER_REFERRER_POLICY\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$NGINX_HEADER_PERMISSIONS_POLICY" ]]; then
sed -i "s|\(^NGINX_HEADER_PERMISSIONS_POLICY=\).*|NGINX_HEADER_PERMISSIONS_POLICY=\"$NGINX_HEADER_PERMISSIONS_POLICY\"|g" "$TMP_SS_CONFIG"
fi


if [[ -n "$NGINX_HEADER_FEATURE_POLICY" ]]; then
sed -i "s|\(^NGINX_HEADER_FEATURE_POLICY=\).*|NGINX_HEADER_FEATURE_POLICY=\"$NGINX_HEADER_FEATURE_POLICY\"|g" "$TMP_SS_CONFIG"
fi



## copy over open file cache settings ##
if [[ -n "$OPEN_FILE_CACHE_MAX" ]]; then
sed -i "s|\(^OPEN_FILE_CACHE_MAX=\).*|OPEN_FILE_CACHE_MAX=\"$OPEN_FILE_CACHE_MAX\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$OPEN_FILE_CACHE_INACTIVE" ]]; then
sed -i "s|\(^OPEN_FILE_CACHE_INACTIVE=\).*|OPEN_FILE_CACHE_INACTIVE=\"$OPEN_FILE_CACHE_INACTIVE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$OPEN_FILE_CACHE_VALID" ]]; then
sed -i "s|\(^OPEN_FILE_CACHE_VALID=\).*|OPEN_FILE_CACHE_VALID=\"$OPEN_FILE_CACHE_VALID\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$OPEN_FILE_CACHE_MIN_USES" ]]; then
sed -i "s|\(^OPEN_FILE_CACHE_MIN_USES=\).*|OPEN_FILE_CACHE_MIN_USES=\"$OPEN_FILE_CACHE_MIN_USES\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$OPEN_FILE_CACHE_ERRORS" ]]; then
sed -i "s|\(^OPEN_FILE_CACHE_ERRORS=\).*|OPEN_FILE_CACHE_ERRORS=\"$OPEN_FILE_CACHE_ERRORS\"|g" "$TMP_SS_CONFIG"
fi

## copy over fastcgi cache settings ##
if [[ -n "$FCGI_CACHE" ]]; then
sed -i "s|\(^FCGI_CACHE=\).*|FCGI_CACHE=\"$FCGI_CACHE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$FCGI_CACHE_VALID" ]]; then
sed -i "s|\(^FCGI_CACHE_VALID=\).*|FCGI_CACHE_VALID=\"$FCGI_CACHE_VALID\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$FCGI_CACHE_INACTIVE" ]]; then
sed -i "s|\(^FCGI_CACHE_INACTIVE=\).*|FCGI_CACHE_INACTIVE=\"$FCGI_CACHE_INACTIVE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$FCGI_CACHE_MEMORY" ]]; then
sed -i "s|\(^FCGI_CACHE_MEMORY=\).*|FCGI_CACHE_MEMORY=\"$FCGI_CACHE_MEMORY\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$FCGI_CACHE_MAX_SIZE" ]]; then
sed -i "s|\(^FCGI_CACHE_MAX_SIZE=\).*|FCGI_CACHE_MAX_SIZE=\"$FCGI_CACHE_MAX_SIZE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$FCGI_CONNECT_TIMEOUT" ]]; then
sed -i "s|\(^FCGI_CONNECT_TIMEOUT=\).*|FCGI_CONNECT_TIMEOUT=\"$FCGI_CONNECT_TIMEOUT\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$FCGI_READ_TIMEOUT" ]]; then
sed -i "s|\(^FCGI_READ_TIMEOUT=\).*|FCGI_READ_TIMEOUT=\"$FCGI_READ_TIMEOUT\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$FCGI_SEND_TIMEOUT" ]]; then
sed -i "s|\(^FCGI_SEND_TIMEOUT=\).*|FCGI_SEND_TIMEOUT=\"$FCGI_SEND_TIMEOUT\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$FCGI_BUFFERS" ]]; then
sed -i "s|\(^FCGI_BUFFERS=\).*|FCGI_BUFFERS=\"$FCGI_BUFFERS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$FCGI_BUFFER_SIZE" ]]; then
sed -i "s|\(^FCGI_BUFFER_SIZE=\).*|FCGI_BUFFER_SIZE=\"$FCGI_BUFFER_SIZE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$FCGI_BUSY_BUFFERS_SIZE" ]]; then
sed -i "s|\(^FCGI_BUSY_BUFFERS_SIZE=\).*|FCGI_BUSY_BUFFERS_SIZE=\"$FCGI_BUSY_BUFFERS_SIZE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$FCGI_TEMP_FILE_WRITE_SIZE" ]]; then
sed -i "s|\(^FCGI_TEMP_FILE_WRITE_SIZE=\).*|FCGI_TEMP_FILE_WRITE_SIZE=\"$FCGI_TEMP_FILE_WRITE_SIZE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$FCGI_CACHE_TMPFS" ]]; then
sed -i "s|\(^FCGI_CACHE_TMPFS=\).*|FCGI_CACHE_TMPFS=\"$FCGI_CACHE_TMPFS\"|g" "$TMP_SS_CONFIG"
fi


## copy over mysql settings ##
if [[ -n "$SQL_MODE" ]]; then
sed -i "s|\(^SQL_MODE=\).*|SQL_MODE=\"$SQL_MODE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SQL_MAX_ALLOWED_PACKET" ]]; then
sed -i "s|\(^SQL_MAX_ALLOWED_PACKET=\).*|SQL_MAX_ALLOWED_PACKET=\"$SQL_MAX_ALLOWED_PACKET\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SQL_CONNECT_TIMEOUT" ]]; then
sed -i "s|\(^SQL_CONNECT_TIMEOUT=\).*|SQL_CONNECT_TIMEOUT=\"$SQL_CONNECT_TIMEOUT\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SQL_WAIT_TIMEOUT" ]]; then
sed -i "s|\(^SQL_WAIT_TIMEOUT=\).*|SQL_WAIT_TIMEOUT=\"$SQL_WAIT_TIMEOUT\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SQL_INTERACTIVE_TIMEOUT" ]]; then
sed -i "s|\(^SQL_INTERACTIVE_TIMEOUT=\).*|SQL_INTERACTIVE_TIMEOUT=\"$SQL_INTERACTIVE_TIMEOUT\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SQL_NET_READ_TIMEOUT" ]]; then
sed -i "s|\(^SQL_NET_READ_TIMEOUT=\).*|SQL_NET_READ_TIMEOUT=\"$SQL_NET_READ_TIMEOUT\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SQL_NET_WRITE_TIMEOUT" ]]; then
sed -i "s|\(^SQL_NET_WRITE_TIMEOUT=\).*|SQL_NET_WRITE_TIMEOUT=\"$SQL_NET_WRITE_TIMEOUT\"|g" "$TMP_SS_CONFIG"
fi



## InnoDB (MySQL) settings ##

if [[ -n "$INNODB_BUFFER_POOL_SIZE" ]]; then
sed -i "s|\(^INNODB_BUFFER_POOL_SIZE=\).*|INNODB_BUFFER_POOL_SIZE=\"$INNODB_BUFFER_POOL_SIZE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$INNODB_LOG_FILE_SIZE" ]]; then
sed -i "s|\(^INNODB_LOG_FILE_SIZE=\).*|INNODB_LOG_FILE_SIZE=\"$INNODB_LOG_FILE_SIZE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$INNODB_LOG_FILES_IN_GROUP" ]]; then
sed -i "s|\(^INNODB_LOG_FILES_IN_GROUP=\).*|INNODB_LOG_FILES_IN_GROUP=\"$INNODB_LOG_FILES_IN_GROUP\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$INNODB_FLUSH_LOG_AT_TRX_COMMIT" ]]; then
sed -i "s|\(^INNODB_FLUSH_LOG_AT_TRX_COMMIT=\).*|INNODB_FLUSH_LOG_AT_TRX_COMMIT=\"$INNODB_FLUSH_LOG_AT_TRX_COMMIT\"|g" "$TMP_SS_CONFIG"
fi

## innodb flush method ##
if [[ -n "$INNODB_FLUSH_METHOD" ]]; then
sed -i "s|\(^INNODB_FLUSH_METHOD=\).*|INNODB_FLUSH_METHOD=\"$INNODB_FLUSH_METHOD\"|g" "$TMP_SS_CONFIG"
fi

## innodb flush method fix for mysql 8.0 upgrades from 5.7 (etc) ##
sed -i "s#INNODB_FLUSH_METHOD="O_DIRECT"#INNODB_FLUSH_METHOD="O_DIRECT_NO_FSYNC"#g" "$TMP_SS_CONFIG"


## copy over php settings ##
if [[ -n "$PHP_PRECISION" ]]; then
sed -i "s|\(^PHP_PRECISION=\).*|PHP_PRECISION=\"$PHP_PRECISION\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$PHP_OUTPUT_BUFFERING" ]]; then
sed -i "s|\(^PHP_OUTPUT_BUFFERING=\).*|PHP_OUTPUT_BUFFERING=\"$PHP_OUTPUT_BUFFERING\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$PHP_UNSERIALIZE_MAX_DEPTH" ]]; then
sed -i "s|\(^PHP_UNSERIALIZE_MAX_DEPTH=\).*|PHP_UNSERIALIZE_MAX_DEPTH=\"$PHP_UNSERIALIZE_MAX_DEPTH\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$PHP_SERIALIZE_PRECISION" ]]; then
sed -i "s|\(^PHP_SERIALIZE_PRECISION=\).*|PHP_SERIALIZE_PRECISION=\"$PHP_SERIALIZE_PRECISION\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$PHP_DISABLE_FUNCTIONS" ]]; then
sed -i "s|\(^PHP_DISABLE_FUNCTIONS=\).*|PHP_DISABLE_FUNCTIONS=\"$PHP_DISABLE_FUNCTIONS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$PHP_DISABLE_CLASSES" ]]; then
sed -i "s|\(^PHP_DISABLE_CLASSES=\).*|PHP_DISABLE_CLASSES=\"$PHP_DISABLE_CLASSES\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$PHP_MAX_EXECUTION_TIME" ]]; then
sed -i "s|\(^PHP_MAX_EXECUTION_TIME=\).*|PHP_MAX_EXECUTION_TIME=\"$PHP_MAX_EXECUTION_TIME\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$PHP_MAX_INPUT_TIME" ]]; then
sed -i "s|\(^PHP_MAX_INPUT_TIME=\).*|PHP_MAX_INPUT_TIME=\"$PHP_MAX_INPUT_TIME\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$PHP_MAX_INPUT_NESTING_LEVEL" ]]; then
sed -i "s|\(^PHP_MAX_INPUT_NESTING_LEVEL=\).*|PHP_MAX_INPUT_NESTING_LEVEL=\"$PHP_MAX_INPUT_NESTING_LEVEL\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$PHP_MAX_INPUT_VARS" ]]; then
sed -i "s|\(^PHP_MAX_INPUT_VARS=\).*|PHP_MAX_INPUT_VARS=\"$PHP_MAX_INPUT_VARS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$PHP_MEMORY_LIMIT" ]]; then
sed -i "s|\(^PHP_MEMORY_LIMIT=\).*|PHP_MEMORY_LIMIT=\"$PHP_MEMORY_LIMIT\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$PHP_POST_MAX_SIZE" ]]; then
sed -i "s|\(^PHP_POST_MAX_SIZE=\).*|PHP_POST_MAX_SIZE=\"$PHP_POST_MAX_SIZE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$PHP_UPLOAD_MAX_FILESIZE" ]]; then
sed -i "s|\(^PHP_UPLOAD_MAX_FILESIZE=\).*|PHP_UPLOAD_MAX_FILESIZE=\"$PHP_UPLOAD_MAX_FILESIZE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$PHP_MAX_FILE_UPLOADS" ]]; then
sed -i "s|\(^PHP_MAX_FILE_UPLOADS=\).*|PHP_MAX_FILE_UPLOADS=\"$PHP_MAX_FILE_UPLOADS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$PHP_ALLOW_URL_FOPEN" ]]; then
sed -i "s|\(^PHP_ALLOW_URL_FOPEN=\).*|PHP_ALLOW_URL_FOPEN=\"$PHP_ALLOW_URL_FOPEN\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$PHP_DEFAULT_SOCKET_TIMEOUT" ]]; then
sed -i "s|\(^PHP_DEFAULT_SOCKET_TIMEOUT=\).*|PHP_DEFAULT_SOCKET_TIMEOUT=\"$PHP_DEFAULT_SOCKET_TIMEOUT\"|g" "$TMP_SS_CONFIG"
fi


## php extensions ##
if [[ -n "$PHP_EXTENSIONS" ]]; then
sed -i "s|\(^PHP_EXTENSIONS=\).*|PHP_EXTENSIONS=\"$PHP_EXTENSIONS\"|g" "$TMP_SS_CONFIG"
fi




## copy over fpm settings ##
if [[ -n "$FPM_EMERGENCY_RESTART_THRESHOLD" ]]; then
sed -i "s|\(^FPM_EMERGENCY_RESTART_THRESHOLD=\).*|FPM_EMERGENCY_RESTART_THRESHOLD=\"$FPM_EMERGENCY_RESTART_THRESHOLD\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$FPM_EMERGENCY_RESTART_INTERVAL" ]]; then
sed -i "s|\(^FPM_EMERGENCY_RESTART_INTERVAL=\).*|FPM_EMERGENCY_RESTART_INTERVAL=\"$FPM_EMERGENCY_RESTART_INTERVAL\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$FPM_PROCESS_CONTROL_TIMEOUT" ]]; then
sed -i "s|\(^FPM_PROCESS_CONTROL_TIMEOUT=\).*|FPM_PROCESS_CONTROL_TIMEOUT=\"$FPM_PROCESS_CONTROL_TIMEOUT\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$FPM_PROCESS_MAX" ]]; then
sed -i "s|\(^FPM_PROCESS_MAX=\).*|FPM_PROCESS_MAX=\"$FPM_PROCESS_MAX\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$FPM_PROCESS_PRIORITY" ]]; then
sed -i "s|\(^FPM_PROCESS_PRIORITY=\).*|FPM_PROCESS_PRIORITY=\"$FPM_PROCESS_PRIORITY\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$FPM_RLIMIT_FILES" ]]; then
sed -i "s|\(^FPM_RLIMIT_FILES=\).*|FPM_RLIMIT_FILES=\"$FPM_RLIMIT_FILES\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$FPM_RLIMIT_CORE" ]]; then
sed -i "s|\(^FPM_RLIMIT_CORE=\).*|FPM_RLIMIT_CORE=\"$FPM_RLIMIT_CORE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$FPM_SYSTEMD_INTERVAL" ]]; then
sed -i "s|\(^FPM_SYSTEMD_INTERVAL=\).*|FPM_SYSTEMD_INTERVAL=\"$FPM_SYSTEMD_INTERVAL\"|g" "$TMP_SS_CONFIG"
fi


## copy over www pool settings ##
if [[ -n "$WWW_LISTEN_BACKLOG" ]]; then
sed -i "s|\(^WWW_LISTEN_BACKLOG=\).*|WWW_LISTEN_BACKLOG=\"$WWW_LISTEN_BACKLOG\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$WWW_PM_MODE" ]]; then
sed -i "s|\(^WWW_PM_MODE=\).*|WWW_PM_MODE=\"$WWW_PM_MODE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$WWW_PM_MAX_CHILDREN" ]]; then
sed -i "s|\(^WWW_PM_MAX_CHILDREN=\).*|WWW_PM_MAX_CHILDREN=\"$WWW_PM_MAX_CHILDREN\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$WWW_PM_START_SERVERS" ]]; then
sed -i "s|\(^WWW_PM_START_SERVERS=\).*|WWW_PM_START_SERVERS=\"$WWW_PM_START_SERVERS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$WWW_PM_MIN_SPARE_SERVERS" ]]; then
sed -i "s|\(^WWW_PM_MIN_SPARE_SERVERS=\).*|WWW_PM_MIN_SPARE_SERVERS=\"$WWW_PM_MIN_SPARE_SERVERS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$WWW_PM_MAX_SPARE_SERVERS" ]]; then
sed -i "s|\(^WWW_PM_MAX_SPARE_SERVERS=\).*|WWW_PM_MAX_SPARE_SERVERS=\"$WWW_PM_MAX_SPARE_SERVERS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$WWW_PM_PROCESS_IDLE_TIMEOUT" ]]; then
sed -i "s|\(^WWW_PM_PROCESS_IDLE_TIMEOUT=\).*|WWW_PM_PROCESS_IDLE_TIMEOUT=\"$WWW_PM_PROCESS_IDLE_TIMEOUT\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$WWW_PM_MAX_REQUESTS" ]]; then
sed -i "s|\(^WWW_PM_MAX_REQUESTS=\).*|WWW_PM_MAX_REQUESTS=\"$WWW_PM_MAX_REQUESTS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$WWW_REQUEST_TERMINATE_TIMEOUT" ]]; then
sed -i "s|\(^WWW_REQUEST_TERMINATE_TIMEOUT=\).*|WWW_REQUEST_TERMINATE_TIMEOUT=\"$WWW_REQUEST_TERMINATE_TIMEOUT\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$WWW_RLIMIT_FILES" ]]; then
sed -i "s|\(^WWW_RLIMIT_FILES=\).*|WWW_RLIMIT_FILES=\"$WWW_RLIMIT_FILES\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$WWW_RLIMIT_CORE" ]]; then
sed -i "s|\(^WWW_RLIMIT_CORE=\).*|WWW_RLIMIT_CORE=\"$WWW_RLIMIT_CORE\"|g" "$TMP_SS_CONFIG"
fi


## copy over opcache settings ##
if [[ -n "$OPCACHE_MEMORY_CONSUMPTION" ]]; then
sed -i "s|\(^OPCACHE_MEMORY_CONSUMPTION=\).*|OPCACHE_MEMORY_CONSUMPTION=\"$OPCACHE_MEMORY_CONSUMPTION\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$OPCACHE_INTERNED_STRINGS_BUFFER" ]]; then
sed -i "s|\(^OPCACHE_INTERNED_STRINGS_BUFFER=\).*|OPCACHE_INTERNED_STRINGS_BUFFER=\"$OPCACHE_INTERNED_STRINGS_BUFFER\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$OPCACHE_MAX_ACCELERATED_FILES" ]]; then
sed -i "s|\(^OPCACHE_MAX_ACCELERATED_FILES=\).*|OPCACHE_MAX_ACCELERATED_FILES=\"$OPCACHE_MAX_ACCELERATED_FILES\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$OPCACHE_MAX_WASTED_PERCENTAGE" ]]; then
sed -i "s|\(^OPCACHE_MAX_WASTED_PERCENTAGE=\).*|OPCACHE_MAX_WASTED_PERCENTAGE=\"$OPCACHE_MAX_WASTED_PERCENTAGE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$OPCACHE_REVALIDATE_FREQUENCY" ]]; then
sed -i "s|\(^OPCACHE_REVALIDATE_FREQUENCY=\).*|OPCACHE_REVALIDATE_FREQUENCY=\"$OPCACHE_REVALIDATE_FREQUENCY\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$OPCACHE_HUGE_CODE_PAGES" ]]; then
sed -i "s|\(^OPCACHE_HUGE_CODE_PAGES=\).*|OPCACHE_HUGE_CODE_PAGES=\"$OPCACHE_HUGE_CODE_PAGES\"|g" "$TMP_SS_CONFIG"
fi


## copy over general slickstack settings ##

## currently we only support wordpress so no reason to copy this over ##
if [[ -n "$SS_APP" ]]; then
    sed -i "s|\(^SS_APP=\).*|SS_APP=\"$SS_APP\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_DASHBOARD" ]]; then
sed -i "s|\(^SS_DASHBOARD=\).*|SS_DASHBOARD=\"$SS_DASHBOARD\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_MU_PLUGINS" ]]; then
sed -i "s|\(^SS_MU_PLUGINS=\).*|SS_MU_PLUGINS=\"$SS_MU_PLUGINS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_PLUGIN_BLACKLIST" ]]; then
sed -i "s|\(^SS_PLUGIN_BLACKLIST=\).*|SS_PLUGIN_BLACKLIST=\"$SS_PLUGIN_BLACKLIST\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_REBOOT" ]]; then
sed -i "s|\(^SS_REBOOT=\).*|SS_REBOOT=\"$SS_REBOOT\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_SWAPFILE" ]]; then
sed -i "s|\(^SS_SWAPFILE=\).*|SS_SWAPFILE=\"$SWAPFILE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_SWAPFILE_SIZE" ]]; then
sed -i "s|\(^SS_SWAPFILE_SIZE=\).*|SS_SWAPFILE_SIZE=\"$SWAPFILE_SIZE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_TIMEZONE" ]]; then
sed -i "s|\(^SS_TIMEZONE=\).*|SS_TIMEZONE=\"$SS_TIMEZONE\"|g" "$TMP_SS_CONFIG"
fi



## SS CORE SCRIPTS SETTINGS ##

## ss-dump ##
if [[ -n "$SS_DUMP_MYSQL_DB" ]]; then
sed -i "s|\(^SS_DUMP_MYSQL_DB=\).*|SS_DUMP_MYSQL_DB=\"$SS_DUMP_MYSQL_DB\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_DUMP_MYSQL_FILES" ]]; then
sed -i "s|\(^SS_DUMP_MYSQL_FILES=\).*|SS_DUMP_MYSQL_FILES=\"$SS_DUMP_MYSQL_FILES\"|g" "$TMP_SS_CONFIG"
fi

## ss-install-wordpress-core ##
if [[ -n "$SS_INSTALL_WORDPRESS_CORE_DELETE_BUNDLED_THEMES" ]]; then
sed -i "s|\(^SS_INSTALL_WORDPRESS_CORE_DELETE_BUNDLED_THEMES=\).*|SS_INSTALL_WORDPRESS_CORE_DELETE_BUNDLED_THEMES=\"$SS_INSTALL_WORDPRESS_CORE_DELETE_BUNDLED_THEMES\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INSTALL_WORDPRESS_CORE_DELETE_BUNDLED_PLUGINS" ]]; then
sed -i "s|\(^SS_INSTALL_WORDPRESS_CORE_DELETE_BUNDLED_PLUGINS=\).*|SS_INSTALL_WORDPRESS_CORE_DELETE_BUNDLED_PLUGINS=\"$SS_INSTALL_WORDPRESS_CORE_DELETE_BUNDLED_PLUGINS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INSTALL_WORDPRESS_CORE_DELETE_PHP_FILES_ROOT" ]]; then
sed -i "s|\(^SS_INSTALL_WORDPRESS_CORE_DELETE_PHP_FILES_ROOT=\).*|SS_INSTALL_WORDPRESS_CORE_DELETE_PHP_FILES_ROOT=\"$SS_INSTALL_WORDPRESS_CORE_DELETE_PHP_FILES_ROOT\"|g" "$TMP_SS_CONFIG"
fi

# SS_INSTALL_WORDPRESS_CORE_DELETE_PHP_FILES_WP_CONTENT="true"

if [[ -n "$SS_INSTALL_WORDPRESS_CORE_DELETE_WP_ADMIN" ]]; then
sed -i "s|\(^SS_INSTALL_WORDPRESS_CORE_DELETE_WP_ADMIN=\).*|SS_INSTALL_WORDPRESS_CORE_DELETE_WP_ADMIN=\"$SS_INSTALL_WORDPRESS_CORE_DELETE_WP_ADMIN\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INSTALL_WORDPRESS_CORE_DELETE_WP_INCLUDES" ]]; then
sed -i "s|\(^SS_INSTALL_WORDPRESS_CORE_DELETE_WP_INCLUDES=\).*|SS_INSTALL_WORDPRESS_CORE_DELETE_WP_INCLUDES=\"$SS_INSTALL_WORDPRESS_CORE_DELETE_WP_INCLUDES\"|g" "$TMP_SS_CONFIG"
fi



## custom source files ##
if [[ -n "PLUGIN_BLACKLIST_SOURCE" ]]; then
sed -i "s|\(^PLUGIN_BLACKLIST_SOURCE=\).*|PLUGIN_BLACKLIST_SOURCE=\"$PLUGIN_BLACKLIST_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "CUSTOM_FUNCTIONS_SOURCE" ]]; then
sed -i "s|\(^CUSTOM_FUNCTIONS_SOURCE=\).*|CUSTOM_FUNCTIONS_SOURCE=\"$CUSTOM_FUNCTIONS_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "THROWAWAY_THEME_SOURCE" ]]; then
sed -i "s|\(^THROWAWAY_THEME_SOURCE=\).*|THROWAWAY_THEME_SOURCE=\"$THROWAWAY_THEME_SOURCE\"|g" "$TMP_SS_CONFIG"
fi



## INTERVAL SETTINGS ##

## copy over ss interval settings ##
if [[ -n "$SS_INTERVAL_CHECK" ]]; then
sed -i "s|\(^SS_INTERVAL_CHECK=\).*|SS_INTERVAL_CHECK=\"$SS_INTERVAL_CHECK\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_CLEAN_FILES" ]]; then
sed -i "s|\(^SS_INTERVAL_CLEAN_FILES=\).*|SS_INTERVAL_CLEAN_FILES=\"$SS_INTERVAL_CLEAN_FILES\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_DOS2UNIX" ]]; then
sed -i "s|\(^SS_INTERVAL_DOS2UNIX=\).*|SS_INTERVAL_DOS2UNIX=\"$SS_INTERVAL_DOS2UNIX\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_DUMP_DATABASE" ]]; then
sed -i "s|\(^SS_INTERVAL_DUMP_DATABASE=\).*|SS_INTERVAL_DUMP_DATABASE=\"$SS_INTERVAL_DUMP_DATABASE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_ENCRYPT" ]]; then
sed -i "s|\(^SS_INTERVAL_ENCRYPT=\).*|SS_INTERVAL_ENCRYPT=\"$SS_INTERVAL_ENCRYPT\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_OPTIMIZE_DATABASE" ]]; then
sed -i "s|\(^SS_INTERVAL_OPTIMIZE_DATABASE=\).*|SS_INTERVAL_OPTIMIZE_DATABASE=\"$SS_INTERVAL_OPTIMIZE_DATABASE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_PERMS" ]]; then
sed -i "s|\(^SS_INTERVAL_PERMS=\).*|SS_INTERVAL_PERMS=\"$SS_INTERVAL_PERMS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_REBOOT" ]]; then
sed -i "s|\(^SS_INTERVAL_REBOOT=\).*|SS_INTERVAL_REBOOT=\"$SS_INTERVAL_REBOOT\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_REMOTE" ]]; then
sed -i "s|\(^SS_INTERVAL_REMOTE=\).*|SS_INTERVAL_REMOTE=\"$SS_INTERVAL_REMOTE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_RESET_PASSWORD" ]]; then
sed -i "s|\(^SS_INTERVAL_RESET_PASSWORD=\).*|SS_INTERVAL_RESET_PASSWORD=\"$SS_INTERVAL_RESET_PASSWORD\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_RESTART_SERVICES" ]]; then
sed -i "s|\(^SS_INTERVAL_RESTART_SERVICES=\).*|SS_INTERVAL_RESTART_SERVICES=\"$SS_INTERVAL_RESTART_SERVICES\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_PURGE" ]]; then
sed -i "s|\(^SS_INTERVAL_PURGE=\).*|SS_INTERVAL_PURGE=\"$SS_INTERVAL_PURGE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_SCAN_MALWARE" ]]; then
sed -i "s|\(^SS_INTERVAL_SCAN_MALWARE=\).*|SS_INTERVAL_SCAN_MALWARE=\"$SS_INTERVAL_SCAN_MALWARE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_SYNC_STAGING" ]]; then
sed -i "s|\(^SS_INTERVAL_SYNC_STAGING=\).*|SS_INTERVAL_SYNC_STAGING=\"$SS_INTERVAL_SYNC_STAGING\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_UPDATE" ]]; then
sed -i "s|\(^SS_INTERVAL_UPDATE=\).*|SS_INTERVAL_UPDATE=\"$SS_INTERVAL_UPDATE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_WORKER" ]]; then
sed -i "s|\(^SS_INTERVAL_WORKER=\).*|SS_INTERVAL_WORKER=\"$SS_INTERVAL_WORKER\"|g" "$TMP_SS_CONFIG"
fi


## ss-install subscripts intervals ##

if [[ -n "$SS_INTERVAL_INSTALL_ADMINER" ]]; then
sed -i "s|\(^SS_INTERVAL_INSTALL_ADMINER=\).*|SS_INTERVAL_INSTALL_ADMINER=\"$SS_INTERVAL_INSTALL_ADMINER\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_INSTALL_CLAMAV" ]]; then
sed -i "s|\(^SS_INTERVAL_INSTALL_CLAMAV=\).*|SS_INTERVAL_INSTALL_CLAMAV=\"$SS_INTERVAL_INSTALL_CLAMAV\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_INSTALL_MISC" ]]; then
sed -i "s|\(^SS_INTERVAL_INSTALL_MISC=\).*|SS_INTERVAL_INSTALL_MISC=\"$SS_INTERVAL_INSTALL_MISC\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_INSTALL_MYSQL" ]]; then
sed -i "s|\(^SS_INTERVAL_INSTALL_MYSQL=\).*|SS_INTERVAL_INSTALL_MYSQL=\"$SS_INTERVAL_INSTALL_MYSQL\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_INSTALL_NGINX" ]]; then
sed -i "s|\(^SS_INTERVAL_INSTALL_NGINX=\).*|SS_INTERVAL_INSTALL_NGINX=\"$SS_INTERVAL_INSTALL_NGINX\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_INSTALL_PHP" ]]; then
sed -i "s|\(^SS_INTERVAL_INSTALL_PHP=\).*|SS_INTERVAL_INSTALL_PHP=\"$SS_INTERVAL_INSTALL_PHP\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_INSTALL_POSTFIX" ]]; then
sed -i "s|\(^SS_INTERVAL_INSTALL_POSTFIX=\).*|SS_INTERVAL_INSTALL_POSTFIX=\"$SS_INTERVAL_INSTALL_POSTFIX\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_INSTALL_REDIS" ]]; then
sed -i "s|\(^SS_INTERVAL_INSTALL_REDIS=\).*|SS_INTERVAL_INSTALL_REDIS=\"$SS_INTERVAL_INSTALL_REDIS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_INSTALL_UBUNTU_BASH" ]]; then
sed -i "s|\(^SS_INTERVAL_INSTALL_UBUNTU_BASH=\).*|SS_INTERVAL_INSTALL_UBUNTU_BASH=\"$SS_INTERVAL_INSTALL_UBUNTU_BASH\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_INSTALL_UBUNTU_CRONTAB" ]]; then
sed -i "s|\(^SS_INTERVAL_INSTALL_UBUNTU_CRONTAB=\).*|SS_INTERVAL_INSTALL_UBUNTU_CRONTAB=\"$SS_INTERVAL_INSTALL_UBUNTU_CRONTAB\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_INSTALL_UBUNTU_KERNEL" ]]; then
sed -i "s|\(^SS_INTERVAL_INSTALL_UBUNTU_KERNEL=\).*|SS_INTERVAL_INSTALL_UBUNTU_KERNEL=\"$SS_INTERVAL_INSTALL_UBUNTU_KERNEL\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_INSTALL_UBUNTU_SSH" ]]; then
sed -i "s|\(^SS_INTERVAL_INSTALL_UBUNTU_SSH=\).*|SS_INTERVAL_INSTALL_UBUNTU_SSH=\"$SS_INTERVAL_INSTALL_UBUNTU_SSH\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_INSTALL_UBUNTU_USERS" ]]; then
sed -i "s|\(^SS_INTERVAL_INSTALL_UBUNTU_USERS=\).*|SS_INTERVAL_INSTALL_UBUNTU_USERS=\"$SS_INTERVAL_INSTALL_UBUNTU_USERS\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_INSTALL_UFW" ]]; then
sed -i "s|\(^SS_INTERVAL_INSTALL_UFW=\).*|SS_INTERVAL_INSTALL_UFW=\"$SS_INTERVAL_INSTALL_UFW\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_INSTALL_WORDPRESS_CLI" ]]; then
sed -i "s|\(^SS_INTERVAL_INSTALL_WORDPRESS_CLI=\).*|SS_INTERVAL_INSTALL_WORDPRESS_CLI=\"$SS_INTERVAL_INSTALL_WORDPRESS_CLI\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_INSTALL_WORDPRESS_CONFIG" ]]; then
sed -i "s|\(^SS_INTERVAL_INSTALL_WORDPRESS_CONFIG=\).*|SS_INTERVAL_INSTALL_WORDPRESS_CONFIG=\"$SS_INTERVAL_INSTALL_WORDPRESS_CONFIG\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_INSTALL_WORDPRESS_CORE" ]]; then
sed -i "s|\(^SS_INTERVAL_INSTALL_WORDPRESS_CORE=\).*|SS_INTERVAL_INSTALL_WORDPRESS_CORE=\"$SS_INTERVAL_INSTALL_WORDPRESS_CORE\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_INTERVAL_INSTALL_WORDPRESS_MU_PLUGINS" ]]; then
sed -i "s|\(^SS_INTERVAL_INSTALL_WORDPRESS_MU_PLUGINS=\).*|SS_INTERVAL_INSTALL_WORDPRESS_MU_PLUGINS=\"$SS_INTERVAL_INSTALL_WORDPRESS_MU_PLUGINS\"|g" "$TMP_SS_CONFIG"
fi




## ss custom cron jobs ##

if [[ -n "$SS_CUSTOM_CRON_OFTEN" ]]; then
sed -i "s|\(^SS_CUSTOM_CRON_OFTEN=\).*|SS_CUSTOM_CRON_OFTEN=\"$SS_CUSTOM_CRON_OFTEN\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_CUSTOM_CRON_REGULAR" ]]; then
sed -i "s|\(^SS_CUSTOM_CRON_REGULAR=\).*|SS_CUSTOM_CRON_REGULAR=\"$SS_CUSTOM_CRON_REGULAR\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_CUSTOM_CRON_QUARTER_HOURLY" ]]; then
sed -i "s|\(^SS_CUSTOM_CRON_QUARTER_HOURLY=\).*|SS_CUSTOM_CRON_QUARTER_HOURLY=\"$SS_CUSTOM_CRON_QUARTER_HOURLY\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_CUSTOM_CRON_HALF_HOURLY" ]]; then
sed -i "s|\(^SS_CUSTOM_CRON_HALF_HOURLY=\).*|SS_CUSTOM_CRON_HALF_HOURLY=\"$SS_CUSTOM_CRON_HALF_HOURLY\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_CUSTOM_CRON_HOURLY" ]]; then
sed -i "s|\(^SS_CUSTOM_CRON_HOURLY=\).*|SS_CUSTOM_CRON_HOURLY=\"$SS_CUSTOM_CRON_HOURLY\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_CUSTOM_CRON_QUARTER_DAILY" ]]; then
sed -i "s|\(^SS_CUSTOM_CRON_QUARTER_DAILY=\).*|SS_CUSTOM_CRON_QUARTER_DAILY=\"$SS_CUSTOM_CRON_QUARTER_DAILY\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_CUSTOM_CRON_HALF_DAILY" ]]; then
sed -i "s|\(^SS_CUSTOM_CRON_HALF_DAILY=\).*|SS_CUSTOM_CRON_HALF_DAILY=\"$SS_CUSTOM_CRON_HALF_DAILY\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_CUSTOM_CRON_DAILY" ]]; then
sed -i "s|\(^SS_CUSTOM_CRON_DAILY=\).*|SS_CUSTOM_CRON_DAILY=\"$SS_CUSTOM_CRON_DAILY\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_CUSTOM_CRON_HALF_WEEKLY" ]]; then
sed -i "s|\(^SS_CUSTOM_CRON_HALF_WEEKLY=\).*|SS_CUSTOM_CRON_HALF_WEEKLY=\"$SS_CUSTOM_CRON_HALF_WEEKLY\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_CUSTOM_CRON_WEEKLY" ]]; then
sed -i "s|\(^SS_CUSTOM_CRON_WEEKLY=\).*|SS_CUSTOM_CRON_WEEKLY=\"$SS_CUSTOM_CRON_WEEKLY\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_CUSTOM_CRON_HALF_MONTHLY" ]]; then
sed -i "s|\(^SS_CUSTOM_CRON_HALF_MONTHLY=\).*|SS_CUSTOM_CRON_HALF_MONTHLY=\"$SS_CUSTOM_CRON_HALF_MONTHLY\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_CUSTOM_CRON_MONTHLY" ]]; then
sed -i "s|\(^SS_CUSTOM_CRON_MONTHLY=\).*|SS_CUSTOM_CRON_MONTHLY=\"$SS_CUSTOM_CRON_MONTHLY\"|g" "$TMP_SS_CONFIG"
fi

if [[ -n "$SS_CUSTOM_CRON_SOMETIMES" ]]; then
sed -i "s|\(^SS_CUSTOM_CRON_SOMETIMES=\).*|SS_CUSTOM_CRON_SOMETIMES=\"$SS_CUSTOM_CRON_SOMETIMES\"|g" "$TMP_SS_CONFIG"
fi




## copy over all MU plugins sources ##
if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_01_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_01_SOURCE=\).*|MU_PLUGIN_01_SOURCE=\"$MU_PLUGIN_01_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_01_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_01_DIR=\).*|MU_PLUGIN_01_DIR=\"$MU_PLUGIN_01_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_02_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_02_SOURCE=\).*|MU_PLUGIN_02_SOURCE=\"$MU_PLUGIN_02_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_02_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_02_DIR=\).*|MU_PLUGIN_02_DIR=\"$MU_PLUGIN_02_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_03_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_03_SOURCE=\).*|MU_PLUGIN_03_SOURCE=\"$MU_PLUGIN_03_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_03_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_03_DIR=\).*|MU_PLUGIN_03_DIR=\"$MU_PLUGIN_03_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_04_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_04_SOURCE=\).*|MU_PLUGIN_04_SOURCE=\"$MU_PLUGIN_04_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_04_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_04_DIR=\).*|MU_PLUGIN_04_DIR=\"$MU_PLUGIN_04_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_05_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_05_SOURCE=\).*|MU_PLUGIN_05_SOURCE=\"$MU_PLUGIN_05_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_05_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_05_DIR=\).*|MU_PLUGIN_05_DIR=\"$MU_PLUGIN_05_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_06_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_06_SOURCE=\).*|MU_PLUGIN_06_SOURCE=\"$MU_PLUGIN_06_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_06_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_06_DIR=\).*|MU_PLUGIN_06_DIR=\"$MU_PLUGIN_06_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_07_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_07_SOURCE=\).*|MU_PLUGIN_07_SOURCE=\"$MU_PLUGIN_07_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_07_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_07_DIR=\).*|MU_PLUGIN_07_DIR=\"$MU_PLUGIN_07_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_08_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_08_SOURCE=\).*|MU_PLUGIN_08_SOURCE=\"$MU_PLUGIN_08_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_08_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_08_DIR=\).*|MU_PLUGIN_08_DIR=\"$MU_PLUGIN_08_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_09_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_09_SOURCE=\).*|MU_PLUGIN_09_SOURCE=\"$MU_PLUGIN_09_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_09_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_09_DIR=\).*|MU_PLUGIN_09_DIR=\"$MU_PLUGIN_09_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_10_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_10_SOURCE=\).*|MU_PLUGIN_10_SOURCE=\"$MU_PLUGIN_10_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_10_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_10_DIR=\).*|MU_PLUGIN_10_DIR=\"$MU_PLUGIN_10_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_11_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_11_SOURCE=\).*|MU_PLUGIN_11_SOURCE=\"$MU_PLUGIN_11_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_11_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_11_DIR=\).*|MU_PLUGIN_11_DIR=\"$MU_PLUGIN_11_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_12_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_12_SOURCE=\).*|MU_PLUGIN_12_SOURCE=\"$MU_PLUGIN_12_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_12_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_12_DIR=\).*|MU_PLUGIN_12_DIR=\"$MU_PLUGIN_12_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_13_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_13_SOURCE=\).*|MU_PLUGIN_13_SOURCE=\"$MU_PLUGIN_13_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_13_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_13_DIR=\).*|MU_PLUGIN_13_DIR=\"$MU_PLUGIN_13_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_14_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_14_SOURCE=\).*|MU_PLUGIN_14_SOURCE=\"$MU_PLUGIN_14_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_14_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_14_DIR=\).*|MU_PLUGIN_14_DIR=\"$MU_PLUGIN_14_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_15_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_15_SOURCE=\).*|MU_PLUGIN_15_SOURCE=\"$MU_PLUGIN_15_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_15_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_15_DIR=\).*|MU_PLUGIN_15_DIR=\"$MU_PLUGIN_15_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_16_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_16_SOURCE=\).*|MU_PLUGIN_16_SOURCE=\"$MU_PLUGIN_16_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_16_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_16_DIR=\).*|MU_PLUGIN_16_DIR=\"$MU_PLUGIN_16_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_17_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_17_SOURCE=\).*|MU_PLUGIN_17_SOURCE=\"$MU_PLUGIN_17_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_17_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_17_DIR=\).*|MU_PLUGIN_17_DIR=\"$MU_PLUGIN_17_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_18_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_18_SOURCE=\).*|MU_PLUGIN_18_SOURCE=\"$MU_PLUGIN_18_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_18_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_18_DIR=\).*|MU_PLUGIN_18_DIR=\"$MU_PLUGIN_18_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_19_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_19_SOURCE=\).*|MU_PLUGIN_19_SOURCE=\"$MU_PLUGIN_19_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_19_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_19_DIR=\).*|MU_PLUGIN_19_DIR=\"$MU_PLUGIN_19_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_20_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_20_SOURCE=\).*|MU_PLUGIN_20_SOURCE=\"$MU_PLUGIN_20_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_20_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_20_DIR=\).*|MU_PLUGIN_20_DIR=\"$MU_PLUGIN_20_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_21_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_21_SOURCE=\).*|MU_PLUGIN_21_SOURCE=\"$MU_PLUGIN_21_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_21_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_21_DIR=\).*|MU_PLUGIN_21_DIR=\"$MU_PLUGIN_21_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_22_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_22_SOURCE=\).*|MU_PLUGIN_22_SOURCE=\"$MU_PLUGIN_22_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_22_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_22_DIR=\).*|MU_PLUGIN_22_DIR=\"$MU_PLUGIN_22_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_23_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_23_SOURCE=\).*|MU_PLUGIN_23_SOURCE=\"$MU_PLUGIN_23_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_23_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_23_DIR=\).*|MU_PLUGIN_23_DIR=\"$MU_PLUGIN_23_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_24_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_24_SOURCE=\).*|MU_PLUGIN_24_SOURCE=\"$MU_PLUGIN_24_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_24_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_24_DIR=\).*|MU_PLUGIN_24_DIR=\"$MU_PLUGIN_24_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_25_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_25_SOURCE=\).*|MU_PLUGIN_25_SOURCE=\"$MU_PLUGIN_25_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_25_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_25_DIR=\).*|MU_PLUGIN_25_DIR=\"$MU_PLUGIN_25_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_26_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_26_SOURCE=\).*|MU_PLUGIN_26_SOURCE=\"$MU_PLUGIN_26_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_26_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_26_DIR=\).*|MU_PLUGIN_26_DIR=\"$MU_PLUGIN_26_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_27_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_27_SOURCE=\).*|MU_PLUGIN_27_SOURCE=\"$MU_PLUGIN_27_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_27_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_27_DIR=\).*|MU_PLUGIN_27_DIR=\"$MU_PLUGIN_27_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_28_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_28_SOURCE=\).*|MU_PLUGIN_28_SOURCE=\"$MU_PLUGIN_28_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_28_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_28_DIR=\).*|MU_PLUGIN_28_DIR=\"$MU_PLUGIN_28_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_29_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_29_SOURCE=\).*|MU_PLUGIN_29_SOURCE=\"$MU_PLUGIN_29_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_29_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_29_DIR=\).*|MU_PLUGIN_29_DIR=\"$MU_PLUGIN_29_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_30_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_30_SOURCE=\).*|MU_PLUGIN_30_SOURCE=\"$MU_PLUGIN_30_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_30_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_30_DIR=\).*|MU_PLUGIN_30_DIR=\"$MU_PLUGIN_30_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_31_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_31_SOURCE=\).*|MU_PLUGIN_31_SOURCE=\"$MU_PLUGIN_31_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_31_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_31_DIR=\).*|MU_PLUGIN_31_DIR=\"$MU_PLUGIN_31_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_32_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_32_SOURCE=\).*|MU_PLUGIN_32_SOURCE=\"$MU_PLUGIN_32_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_32_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_32_DIR=\).*|MU_PLUGIN_32_DIR=\"$MU_PLUGIN_32_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_33_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_33_SOURCE=\).*|MU_PLUGIN_33_SOURCE=\"$MU_PLUGIN_33_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_33_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_33_DIR=\).*|MU_PLUGIN_33_DIR=\"$MU_PLUGIN_33_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_34_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_34_SOURCE=\).*|MU_PLUGIN_34_SOURCE=\"$MU_PLUGIN_34_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_34_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_34_DIR=\).*|MU_PLUGIN_34_DIR=\"$MU_PLUGIN_34_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_35_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_35_SOURCE=\).*|MU_PLUGIN_35_SOURCE=\"$MU_PLUGIN_35_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_35_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_35_DIR=\).*|MU_PLUGIN_35_DIR=\"$MU_PLUGIN_35_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_36_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_36_SOURCE=\).*|MU_PLUGIN_36_SOURCE=\"$MU_PLUGIN_36_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_36_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_36_DIR=\).*|MU_PLUGIN_36_DIR=\"$MU_PLUGIN_36_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_37_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_37_SOURCE=\).*|MU_PLUGIN_37_SOURCE=\"$MU_PLUGIN_37_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_37_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_37_DIR=\).*|MU_PLUGIN_37_DIR=\"$MU_PLUGIN_37_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_38_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_38_SOURCE=\).*|MU_PLUGIN_38_SOURCE=\"$MU_PLUGIN_38_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_38_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_38_DIR=\).*|MU_PLUGIN_38_DIR=\"$MU_PLUGIN_38_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_39_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_39_SOURCE=\).*|MU_PLUGIN_39_SOURCE=\"$MU_PLUGIN_39_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_39_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_39_DIR=\).*|MU_PLUGIN_39_DIR=\"$MU_PLUGIN_39_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_40_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_40_SOURCE=\).*|MU_PLUGIN_40_SOURCE=\"$MU_PLUGIN_40_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_40_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_40_DIR=\).*|MU_PLUGIN_40_DIR=\"$MU_PLUGIN_40_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_41_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_41_SOURCE=\).*|MU_PLUGIN_41_SOURCE=\"$MU_PLUGIN_41_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_41_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_41_DIR=\).*|MU_PLUGIN_41_DIR=\"$MU_PLUGIN_41_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_42_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_42_SOURCE=\).*|MU_PLUGIN_42_SOURCE=\"$MU_PLUGIN_42_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_42_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_42_DIR=\).*|MU_PLUGIN_42_DIR=\"$MU_PLUGIN_42_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_43_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_43_SOURCE=\).*|MU_PLUGIN_43_SOURCE=\"$MU_PLUGIN_43_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_43_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_43_DIR=\).*|MU_PLUGIN_43_DIR=\"$MU_PLUGIN_43_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_44_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_44_SOURCE=\).*|MU_PLUGIN_44_SOURCE=\"$MU_PLUGIN_44_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_44_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_44_DIR=\).*|MU_PLUGIN_44_DIR=\"$MU_PLUGIN_44_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_45_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_45_SOURCE=\).*|MU_PLUGIN_45_SOURCE=\"$MU_PLUGIN_45_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_45_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_45_DIR=\).*|MU_PLUGIN_45_DIR=\"$MU_PLUGIN_45_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_46_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_46_SOURCE=\).*|MU_PLUGIN_46_SOURCE=\"$MU_PLUGIN_46_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_46_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_46_DIR=\).*|MU_PLUGIN_46_DIR=\"$MU_PLUGIN_46_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_47_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_47_SOURCE=\).*|MU_PLUGIN_47_SOURCE=\"$MU_PLUGIN_47_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_47_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_47_DIR=\).*|MU_PLUGIN_47_DIR=\"$MU_PLUGIN_47_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_48_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_48_SOURCE=\).*|MU_PLUGIN_48_SOURCE=\"$MU_PLUGIN_48_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_48_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_48_DIR=\).*|MU_PLUGIN_48_DIR=\"$MU_PLUGIN_48_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_49_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_49_SOURCE=\).*|MU_PLUGIN_49_SOURCE=\"$MU_PLUGIN_49_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_49_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_49_DIR=\).*|MU_PLUGIN_49_DIR=\"$MU_PLUGIN_49_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_50_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_50_SOURCE=\).*|MU_PLUGIN_50_SOURCE=\"$MU_PLUGIN_50_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_50_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_50_DIR=\).*|MU_PLUGIN_50_DIR=\"$MU_PLUGIN_50_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_51_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_51_SOURCE=\).*|MU_PLUGIN_51_SOURCE=\"$MU_PLUGIN_51_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_51_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_51_DIR=\).*|MU_PLUGIN_51_DIR=\"$MU_PLUGIN_51_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_52_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_52_SOURCE=\).*|MU_PLUGIN_52_SOURCE=\"$MU_PLUGIN_52_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_52_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_52_DIR=\).*|MU_PLUGIN_52_DIR=\"$MU_PLUGIN_52_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_53_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_53_SOURCE=\).*|MU_PLUGIN_53_SOURCE=\"$MU_PLUGIN_53_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_53_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_53_DIR=\).*|MU_PLUGIN_53_DIR=\"$MU_PLUGIN_53_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_54_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_54_SOURCE=\).*|MU_PLUGIN_54_SOURCE=\"$MU_PLUGIN_54_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_54_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_54_DIR=\).*|MU_PLUGIN_54_DIR=\"$MU_PLUGIN_54_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_55_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_55_SOURCE=\).*|MU_PLUGIN_55_SOURCE=\"$MU_PLUGIN_55_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_55_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_55_DIR=\).*|MU_PLUGIN_55_DIR=\"$MU_PLUGIN_55_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_56_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_56_SOURCE=\).*|MU_PLUGIN_56_SOURCE=\"$MU_PLUGIN_56_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_56_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_56_DIR=\).*|MU_PLUGIN_56_DIR=\"$MU_PLUGIN_56_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_57_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_57_SOURCE=\).*|MU_PLUGIN_57_SOURCE=\"$MU_PLUGIN_57_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_57_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_57_DIR=\).*|MU_PLUGIN_57_DIR=\"$MU_PLUGIN_57_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_58_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_58_SOURCE=\).*|MU_PLUGIN_58_SOURCE=\"$MU_PLUGIN_58_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_58_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_58_DIR=\).*|MU_PLUGIN_58_DIR=\"$MU_PLUGIN_58_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_59_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_59_SOURCE=\).*|MU_PLUGIN_59_SOURCE=\"$MU_PLUGIN_59_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_59_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_59_DIR=\).*|MU_PLUGIN_59_DIR=\"$MU_PLUGIN_59_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_60_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_60_SOURCE=\).*|MU_PLUGIN_60_SOURCE=\"$MU_PLUGIN_60_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_60_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_60_DIR=\).*|MU_PLUGIN_60_DIR=\"$MU_PLUGIN_60_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_61_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_61_SOURCE=\).*|MU_PLUGIN_61_SOURCE=\"$MU_PLUGIN_61_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_61_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_61_DIR=\).*|MU_PLUGIN_61_DIR=\"$MU_PLUGIN_61_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_62_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_62_SOURCE=\).*|MU_PLUGIN_62_SOURCE=\"$MU_PLUGIN_62_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_62_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_62_DIR=\).*|MU_PLUGIN_62_DIR=\"$MU_PLUGIN_62_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_63_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_63_SOURCE=\).*|MU_PLUGIN_63_SOURCE=\"$MU_PLUGIN_63_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_63_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_63_DIR=\).*|MU_PLUGIN_63_DIR=\"$MU_PLUGIN_63_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_64_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_64_SOURCE=\).*|MU_PLUGIN_64_SOURCE=\"$MU_PLUGIN_64_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_64_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_64_DIR=\).*|MU_PLUGIN_64_DIR=\"$MU_PLUGIN_64_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_65_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_65_SOURCE=\).*|MU_PLUGIN_65_SOURCE=\"$MU_PLUGIN_65_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_65_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_65_DIR=\).*|MU_PLUGIN_65_DIR=\"$MU_PLUGIN_65_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_66_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_66_SOURCE=\).*|MU_PLUGIN_66_SOURCE=\"$MU_PLUGIN_66_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_66_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_66_DIR=\).*|MU_PLUGIN_66_DIR=\"$MU_PLUGIN_66_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_67_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_67_SOURCE=\).*|MU_PLUGIN_67_SOURCE=\"$MU_PLUGIN_67_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_67_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_67_DIR=\).*|MU_PLUGIN_67_DIR=\"$MU_PLUGIN_67_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_68_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_68_SOURCE=\).*|MU_PLUGIN_68_SOURCE=\"$MU_PLUGIN_68_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_68_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_68_DIR=\).*|MU_PLUGIN_68_DIR=\"$MU_PLUGIN_68_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_69_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_69_SOURCE=\).*|MU_PLUGIN_69_SOURCE=\"$MU_PLUGIN_69_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_69_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_69_DIR=\).*|MU_PLUGIN_69_DIR=\"$MU_PLUGIN_69_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_70_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_70_SOURCE=\).*|MU_PLUGIN_70_SOURCE=\"$MU_PLUGIN_70_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_70_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_70_DIR=\).*|MU_PLUGIN_70_DIR=\"$MU_PLUGIN_70_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_71_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_71_SOURCE=\).*|MU_PLUGIN_71_SOURCE=\"$MU_PLUGIN_71_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_71_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_71_DIR=\).*|MU_PLUGIN_71_DIR=\"$MU_PLUGIN_71_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_72_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_72_SOURCE=\).*|MU_PLUGIN_72_SOURCE=\"$MU_PLUGIN_72_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_72_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_72_DIR=\).*|MU_PLUGIN_72_DIR=\"$MU_PLUGIN_72_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_73_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_73_SOURCE=\).*|MU_PLUGIN_73_SOURCE=\"$MU_PLUGIN_73_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_73_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_73_DIR=\).*|MU_PLUGIN_73_DIR=\"$MU_PLUGIN_73_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_74_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_74_SOURCE=\).*|MU_PLUGIN_74_SOURCE=\"$MU_PLUGIN_74_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_74_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_74_DIR=\).*|MU_PLUGIN_74_DIR=\"$MU_PLUGIN_74_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_75_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_75_SOURCE=\).*|MU_PLUGIN_75_SOURCE=\"$MU_PLUGIN_75_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_75_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_75_DIR=\).*|MU_PLUGIN_75_DIR=\"$MU_PLUGIN_75_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_76_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_76_SOURCE=\).*|MU_PLUGIN_76_SOURCE=\"$MU_PLUGIN_76_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_76_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_76_DIR=\).*|MU_PLUGIN_76_DIR=\"$MU_PLUGIN_76_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_77_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_77_SOURCE=\).*|MU_PLUGIN_77_SOURCE=\"$MU_PLUGIN_77_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_77_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_77_DIR=\).*|MU_PLUGIN_77_DIR=\"$MU_PLUGIN_77_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_78_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_78_SOURCE=\).*|MU_PLUGIN_78_SOURCE=\"$MU_PLUGIN_78_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_78_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_78_DIR=\).*|MU_PLUGIN_78_DIR=\"$MU_PLUGIN_78_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_79_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_79_SOURCE=\).*|MU_PLUGIN_79_SOURCE=\"$MU_PLUGIN_79_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_79_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_79_DIR=\).*|MU_PLUGIN_79_DIR=\"$MU_PLUGIN_79_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_80_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_80_SOURCE=\).*|MU_PLUGIN_80_SOURCE=\"$MU_PLUGIN_80_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_80_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_80_DIR=\).*|MU_PLUGIN_80_DIR=\"$MU_PLUGIN_80_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_81_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_81_SOURCE=\).*|MU_PLUGIN_81_SOURCE=\"$MU_PLUGIN_81_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_81_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_81_DIR=\).*|MU_PLUGIN_81_DIR=\"$MU_PLUGIN_81_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_82_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_82_SOURCE=\).*|MU_PLUGIN_82_SOURCE=\"$MU_PLUGIN_82_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_82_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_82_DIR=\).*|MU_PLUGIN_82_DIR=\"$MU_PLUGIN_82_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_83_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_83_SOURCE=\).*|MU_PLUGIN_83_SOURCE=\"$MU_PLUGIN_83_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_83_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_83_DIR=\).*|MU_PLUGIN_83_DIR=\"$MU_PLUGIN_83_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_84_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_84_SOURCE=\).*|MU_PLUGIN_84_SOURCE=\"$MU_PLUGIN_84_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_84_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_84_DIR=\).*|MU_PLUGIN_84_DIR=\"$MU_PLUGIN_84_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_85_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_85_SOURCE=\).*|MU_PLUGIN_85_SOURCE=\"$MU_PLUGIN_85_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_85_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_85_DIR=\).*|MU_PLUGIN_85_DIR=\"$MU_PLUGIN_85_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_86_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_86_SOURCE=\).*|MU_PLUGIN_86_SOURCE=\"$MU_PLUGIN_86_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_86_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_86_DIR=\).*|MU_PLUGIN_86_DIR=\"$MU_PLUGIN_86_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_87_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_87_SOURCE=\).*|MU_PLUGIN_87_SOURCE=\"$MU_PLUGIN_87_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_87_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_87_DIR=\).*|MU_PLUGIN_87_DIR=\"$MU_PLUGIN_87_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_88_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_88_SOURCE=\).*|MU_PLUGIN_88_SOURCE=\"$MU_PLUGIN_88_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_88_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_88_DIR=\).*|MU_PLUGIN_88_DIR=\"$MU_PLUGIN_88_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_89_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_89_SOURCE=\).*|MU_PLUGIN_89_SOURCE=\"$MU_PLUGIN_89_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_89_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_89_DIR=\).*|MU_PLUGIN_89_DIR=\"$MU_PLUGIN_89_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_90_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_90_SOURCE=\).*|MU_PLUGIN_90_SOURCE=\"$MU_PLUGIN_90_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_90_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_90_DIR=\).*|MU_PLUGIN_90_DIR=\"$MU_PLUGIN_90_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_91_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_91_SOURCE=\).*|MU_PLUGIN_91_SOURCE=\"$MU_PLUGIN_91_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_91_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_91_DIR=\).*|MU_PLUGIN_91_DIR=\"$MU_PLUGIN_91_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_92_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_92_SOURCE=\).*|MU_PLUGIN_92_SOURCE=\"$MU_PLUGIN_92_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_92_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_92_DIR=\).*|MU_PLUGIN_92_DIR=\"$MU_PLUGIN_92_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_93_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_93_SOURCE=\).*|MU_PLUGIN_93_SOURCE=\"$MU_PLUGIN_93_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_93_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_93_DIR=\).*|MU_PLUGIN_93_DIR=\"$MU_PLUGIN_93_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_94_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_94_SOURCE=\).*|MU_PLUGIN_94_SOURCE=\"$MU_PLUGIN_94_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_94_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_94_DIR=\).*|MU_PLUGIN_94_DIR=\"$MU_PLUGIN_94_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_95_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_95_SOURCE=\).*|MU_PLUGIN_95_SOURCE=\"$MU_PLUGIN_95_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_95_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_95_DIR=\).*|MU_PLUGIN_95_DIR=\"$MU_PLUGIN_95_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_96_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_96_SOURCE=\).*|MU_PLUGIN_96_SOURCE=\"$MU_PLUGIN_96_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_96_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_96_DIR=\).*|MU_PLUGIN_96_DIR=\"$MU_PLUGIN_96_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_97_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_97_SOURCE=\).*|MU_PLUGIN_97_SOURCE=\"$MU_PLUGIN_97_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_97_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_97_DIR=\).*|MU_PLUGIN_97_DIR=\"$MU_PLUGIN_97_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_98_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_98_SOURCE=\).*|MU_PLUGIN_98_SOURCE=\"$MU_PLUGIN_98_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_98_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_98_DIR=\).*|MU_PLUGIN_98_DIR=\"$MU_PLUGIN_98_DIR\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_99_SOURCE" ]]; then
sed -i "s|\(^MU_PLUGIN_99_SOURCE=\).*|MU_PLUGIN_99_SOURCE=\"$MU_PLUGIN_99_SOURCE\"|g" "$TMP_SS_CONFIG"
fi

if [[ "$SS_MU_PLUGINS" == "custom" ]] && [[ -n "$MU_PLUGIN_99_DIR" ]]; then
sed -i "s|\(^MU_PLUGIN_99_DIR=\).*|MU_PLUGIN_99_DIR=\"$MU_PLUGIN_99_DIR\"|g" "$TMP_SS_CONFIG"
fi

####################################################################################################
#### SS-Update-Config: Validate + Install Latest SS-Config Boilerplate #############################
####################################################################################################

## this snippet will ensure that the latest ss-config boilerplate appears intact ##
## then it will proceed to overwrite the current ss-config with the new one ##

## validate/install ss-config boilerplate ##
VALIDATE_TMP_SS_CONFIG=$(grep "$SS_EOF" "$TMP_SS_CONFIG")
DB_NAME_NOW=$(source "$TMP_SS_CONFIG"; echo $DB_NAME)
if [[ -n "$VALIDATE_TMP_SS_CONFIG" ]] && [[ -n "$DB_NAME_NOW" ]]; then
    cp "$TMP_SS_CONFIG" "$PATH_SS_CONFIG"
    chown root:root "$PATH_SS_CONFIG" ## must be root:root
    chmod 0700 "$PATH_SS_CONFIG" ## must be 0700
    echo -e "${GREEN}Exiting ss-update-config: Your ss-config file has been successfully updated to latest boilerplate... ${NOCOLOR}"
else
    echo -e "${DARKRED}Exiting ss-update-config: The retrieved ss-config boilerplate appears corrupt so update was skipped... ${NOCOLOR}"
fi

####################################################################################################
#### SS-Update-Config: Cleanup Temporary Files #####################################################
####################################################################################################

## delete tmp files ##
rm "$TMP_SS_CONFIG"

####################################################################################################
#### SS-Update-Config: Touch Timestamp File (End Script) ###########################################
####################################################################################################

## this is a dummy timestamp file that will remember the last time this script was run ##
## it can be useful for developer reference and is sometimes used by SlickStack ##

## script timestamp ##
touch /var/www/meta/.timestamp-ss-update-config

####################################################################################################
#### SlickStack: External References Used To Improve This Script (Thanks, Interwebz) ###############
####################################################################################################

## Ref: https://linux.die.net/man/8/apt-get
## Ref: https://askubuntu.com/questions/1112555/is-apt-dist-upgrade-not-necessary-anymore
## Ref: https://unix.stackexchange.com/questions/467552/reboot-over-ssh/467996#467996
## Ref: https://askubuntu.com/questions/254129/how-to-display-all-apt-get-dpkgoptions-and-their-current-values
## Ref: https://serverfault.com/questions/48724/100-non-interactive-debian-dist-upgrade
## Ref: https://askubuntu.com/questions/938359/apt-get-install-remove-update-upgrade-via-cron-job
## Ref: http://manpages.ubuntu.com/manpages/trusty/man8/apt.8.html
## Ref: https://www.debian.org/doc/manuals/apt-guide/index.en.html
## Ref: https://serverfault.com/questions/478461/how-to-install-packages-with-apt-without-user-interaction
## Ref: https://serverfault.com/questions/644180/what-does-qq-argument-for-apt-get-mean
## Ref: https://superuser.com/questions/1438031/ubuntu-18-command-apt-get-dist-upgrade-qq-force-yes-deprecated
## Ref: https://superuser.com/questions/1412054/non-interactive-apt-upgrade
## Ref: https://serverfault.com/questions/227190/how-do-i-ask-apt-get-to-skip-any-interactive-post-install-configuration-steps
## Ref: https://bugzilla.redhat.com/show_bug.cgi?id=1253351
## Ref: https://kb.cloudberrylab.com/backup-mac-linux/silent-install-macos-and-linux-builds
## Ref: https://unix.stackexchange.com/questions/32533/debian-how-to-delay-configuration-when-installing-upgrading
## Ref: https://raymii.org/s/tutorials/Silent-automatic-apt-get-upgrade.html
## Ref: https://unix.stackexchange.com/questions/138504/setting-path-vs-exporting-path-in-bash-profile
## Ref: https://askubuntu.com/questions/578568/path-error-in-ubuntu
## Ref: https://stackoverflow.com/questions/38977713/what-is-snap-bin-directory-in-path-can-i-remove-it-from-path
## Ref: https://askubuntu.com/questions/1121495/add-snap-bin-to-path-used-by-systemd
## Ref: https://askubuntu.com/questions/163200/e-dpkg-was-interrupted-run-sudo-dpkg-configure-a
## Ref: https://stackoverflow.com/questions/1305237/how-to-list-variables-declared-in-script-in-bash
## Ref: https://stackoverflow.com/questions/32739572/bash-search-and-replace-value-of-a-variable-inside-a-file
## Ref: https://askubuntu.com/questions/76808/how-do-i-use-variables-in-a-sed-command
## Ref: https://unix.stackexchange.com/questions/69112/how-can-i-use-variables-in-the-lhs-and-rhs-of-a-sed-substitution
## Ref: https://stackoverflow.com/questions/19151954/how-to-use-variables-in-a-command-in-sed
## Ref: https://unix.stackexchange.com/questions/47584/in-a-bash-script-using-the-conditional-or-in-an-if-statement
## Ref: https://stackoverflow.com/questions/11287861/how-to-check-if-a-file-contains-a-specific-string-using-bash
## Ref: https://stackoverflow.com/questions/25564051/how-to-compare-grep-result-with-a-variable
## Ref: https://stackoverflow.com/questions/26458121/grep-a-specific-string-from-bash-script-and-compare
## Ref: https://unix.stackexchange.com/questions/372733/get-output-and-return-value-of-grep-in-single-operation-in-bash
## Ref: https://stackoverflow.com/questions/18789907/read-values-from-configuration-file-and-use-in-shell-script
## Ref: https://stackoverflow.com/questions/38385963/sed-replacing-string-with-quotation-marks
## Ref: https://github.com/littlebizzy/slickstack/issues/36
## Ref: http://manpages.ubuntu.com/manpages/bionic/man1/date.1.html
## Ref: https://crunchify.com/shell-script-append-timestamp-to-file-name/
## Ref: https://stackoverflow.com/questions/6946677/grep-with-quotation-mark
## Ref: https://unix.stackexchange.com/questions/48535/can-grep-return-true-false-or-are-there-alternative-methods

## SS_EOF