#!/bin/sh

echo "KIS for Mac 21.0 - Patch B"
echo "Patch script v. 2.0"

KAV_DIR="/Library/Application Support/Kaspersky Lab/KAV"
KAV_BINARIES_DIR="$KAV_DIR/Binaries"
KAV_DATA_DIR="$KAV_DIR/Data"
KAV_APP_PKG="$KAV_DATA_DIR/kav_app.tar.gz"
KAV_AGENT_PKG="$KAV_DATA_DIR/kav_agent.tar.gz"
KAV_UPDATE_PKG="$KAV_DATA_DIR/kav_update.tar.gz"
KAV_UNINSTALLER_PKG="$KAV_DATA_DIR/kav_uninstaller.tar.gz"
DRIVERS_PKG_DIR="$KAV_DATA_DIR"
DRIVERS_CACHE_DIR="$KAV_DIR/Bases/Cache"
BASES_KLAVA_DIR="$KAV_DIR/Bases/KLAVA"
KAV_AGENT_APP_PATH="$KAV_DIR/Applications/Kaspersky Anti-Virus Agent.app"
KAV_UPDATE_APP_PATH="$KAV_DIR/Applications/Kaspersky Anti-Virus Update.app"
KAV_UNINSTALLER_APP_PATH="$KAV_DIR/Applications/Kaspersky Uninstaller.app"
KAV_AGENT_WATCHPATH="$KAV_DIR/kickstart_gui"
LAUNCHAGENT_DIR="/Library/LaunchAgents"
LAUNCHAGENT_KAV_PLIST="$LAUNCHAGENT_DIR/com.kaspersky.kav.gui.plist"
LAUNCHAGENT_APP_PLIST="$LAUNCHAGENT_DIR/com.kaspersky.kav.app.plist"
KAV_KICKSTART_DIR_APP="$KAV_DIR"/kickstart_app
DEFAULT_KAVAPP_PATH="/Applications/Kaspersky Anti-Virus For Mac.app"
LOC_TGZ="$KAV_DATA_DIR/loc.tar.gz"
LOC_DIR="$KAV_DIR/Loc"
DOC_TGZ="$KAV_DATA_DIR/doc.tar.gz"
DOC_DIR="$KAV_DIR/Doc"
CONFIG_XML_CHANGES_TMP="/tmp/kav_config_xml_changes"

UPDATE_CFG_SCRIPT="$KAV_BINARIES_DIR/update_cfg.pl"
UPDATE_CFG_TARGET="$KAV_BINARIES_DIR/config.xml"

get_environment_key()
{
    python -c """
import xml.etree.ElementTree as ET
tree = ET.parse('$UPDATE_CFG_TARGET')
root = tree.getroot()
for node in root.findall(\".//key[@name='environment']\"):
    for childNode in node.findall(\".//tSTRING[@name='$1']\"):
        print(childNode.text)
    """
}

get_last_patch_deployment()
{
    python -c """
import xml.etree.ElementTree as ET
tree = ET.parse('$UPDATE_CFG_TARGET')
root = tree.getroot()
for node in root.findall(\".//key[@name='Timestamps']\"):
    for childNode in node.findall(\".//tDWORD[@name='LastPatchDeployment']\"):
        print(childNode.text)
    """
}

stop_kav_app()
{
	local KAVAPP_RECORD=$(ps -axwo pid,command | grep -v grep | grep "Contents/MacOS/kav_app")
	local KAVPID=$(/bin/echo -n "$KAVAPP_RECORD" | awk '{print $1}')
	if [ "$KAVPID" != "" ]
	then
		RELAUNCH_KAVAPP_PATH=$(/bin/echo -n "$KAVAPP_RECORD" | sed 's/[ ]*'"$KAVPID"'[ ]*\(.*\.app\).*/\1/')
		kill -s KILL "$KAVPID"
	fi
}

stop_kav_agent()
{
	local KAVPID=$(ps -axwo pid,command | grep -v grep | grep "Contents/MacOS/kav_agent" | awk '{print $1}')
	if [ "$KAVPID" != "" ]
	then
		kill -s KILL $KAVPID
		RESTART_KAVAGENT=1
	fi
}

add_system_version_compat_to_plist()
{
    local PLIST_PATH="$1"

    echo ""
    echo "Adding SYSTEM_VERSION_COMPAT env variable to ${PLIST_PATH}"

    /usr/libexec/PlistBuddy -c "Add :EnvironmentVariables dict" "${PLIST_PATH}"
        [ $? != 0 ] && echo "error: failed to add EnvironmentVariables dictionary to ${PLIST_PATH}"

    /usr/libexec/PlistBuddy -c "Add :EnvironmentVariables:SYSTEM_VERSION_COMPAT string" "${PLIST_PATH}"
        [ $? != 0 ] && echo "error: failed to add SYSTEM_VERSION_COMPAT key to dictionary in ${PLIST_PATH}"

    /usr/libexec/PlistBuddy -c "Set :EnvironmentVariables:SYSTEM_VERSION_COMPAT 0" "${PLIST_PATH}"
        [ $? != 0 ] && echo "error: failed to set SYSTEM_VERSION_COMPAT to 0 in ${PLIST_PATH}"

    return 0
}

deploy_launch_agent()
{
    cp -rfv "${KAV_DATA_DIR}/com.kaspersky.kav.app.plist" "${LAUNCHAGENT_APP_PLIST}"
        [ $? != 0 ] && echo "error: fail to copy com.kaspersky.kav.app.plist to ${LAUNCHAGENT_APP_PLIST}"
    
    chown root:wheel ${LAUNCHAGENT_APP_PLIST}

    echo "Creating ${KAV_KICKSTART_DIR_APP} kickstart app directory"
    mkdir -pv "${KAV_KICKSTART_DIR_APP}"
        [ $? != 0 ] && echo "error: failed to create ${KAV_KICKSTART_DIR_APP}"

    chmod 0777 "${KAV_KICKSTART_DIR_APP}"

    who | awk '{print $1}' | uniq | while read _USER; do
        sudo su - "$_USER" -c "launchctl load -w \"${LAUNCHAGENT_APP_PLIST}\""
    done

    echo "finish deploy launch agent"

    return 0
}

version_less_than()
{
    local LEFT_MAJOR=`echo "$1" | awk -F"." '{printf "%d\n", $1}'`
    local LEFT_MINOR=`echo "$1" | awk -F"." '{printf "%d\n", $2}'`

    local RIGHT_MAJOR=`echo "$2" | awk -F"." '{printf "%d\n", $1}'`
    local RIGHT_MINOR=`echo "$2" | awk -F"." '{printf "%d\n", $2}'`

    [ "$LEFT_MAJOR" -lt "$RIGHT_MAJOR" ] && return 1
    [ "$LEFT_MAJOR" -gt "$RIGHT_MAJOR" ] && return 0

    [ "$LEFT_MINOR" -lt "$RIGHT_MINOR" ] && return 1
    
    return 0
}

if [ "$1" != "OnHotfixInstalled" ]; then
    PRODUCT_TYPE=$(get_environment_key "ProductType")
    echo "ProductType:      $PRODUCT_TYPE"
    REGION_TYPE=$(get_environment_key "ProductRegion")
    echo "ProductRegion:    $REGION_TYPE"
    MATCHED_ARCHIVE="${PRODUCT_TYPE}_${REGION_TYPE}".tar.gz
    echo "Matched archive:  $MATCHED_ARCHIVE"

    if [ -f "$UPDATE_CFG_SCRIPT" ]
    then
    	echo ""
    	echo "Stopping application..."
    	stop_kav_app

    	echo ""
    	echo "Stopping possibly respawned application..."
    	stop_kav_app
    fi

    if [ "$LOC_TGZ" != "" ]
    then
        if [ -e "$LOC_TGZ" ]
        then
            LOC_EXTRACTION_TEMP_PATH=$(mktemp -d)
            echo ""
            echo "Extracting $LOC_TGZ into $LOC_EXTRACTION_TEMP_PATH"
            tar -xzvf "$LOC_TGZ" -C "$LOC_EXTRACTION_TEMP_PATH"
            echo "Extracted: "
            ls -la "$LOC_EXTRACTION_TEMP_PATH"

            echo ""
            echo "Deploying localizations..."
            if [ -f "$LOC_EXTRACTION_TEMP_PATH/$MATCHED_ARCHIVE" ]; then
                CURRENT_LOC_EXTRACTION_TEMP_PATH=$(mktemp -d)
                echo "Extracting application resources from $MATCHED_ARCHIVE to $CURRENT_LOC_EXTRACTION_TEMP_PATH..."
                tar -xzvf "$LOC_EXTRACTION_TEMP_PATH/$MATCHED_ARCHIVE" -C "$CURRENT_LOC_EXTRACTION_TEMP_PATH"
                cp -Rfv "$CURRENT_LOC_EXTRACTION_TEMP_PATH"/ "$LOC_DIR"
            else
                echo "No matched archive in $LOC_EXTRACTION_TEMP_PATH, do not apply patch for $LOC_DIR"
            fi
        fi
    fi

    if [ "$DOC_TGZ" != "" ]
    then
        if [ -e "$DOC_TGZ" ]
        then
            DOC_EXTRACTION_TEMP_PATH=$(mktemp -d)
            echo ""
            echo "Extracting $DOC_TGZ into $DOC_EXTRACTION_TEMP_PATH"
            tar -xzvf "$DOC_TGZ" -C "$DOC_EXTRACTION_TEMP_PATH"
            echo "Extracted: "
            ls -la "$DOC_EXTRACTION_TEMP_PATH"

            echo ""
            echo "Deploying docs..."
            if [ -f "$DOC_EXTRACTION_TEMP_PATH/$MATCHED_ARCHIVE" ]; then
                CURRENT_DOC_EXTRACTION_TEMP_PATH=$(mktemp -d)
                echo "Extracting application resources from $MATCHED_ARCHIVE to $CURRENT_DOC_EXTRACTION_TEMP_PATH..."
                tar -xzvf "$DOC_EXTRACTION_TEMP_PATH/$MATCHED_ARCHIVE" -C "$CURRENT_DOC_EXTRACTION_TEMP_PATH"
                cp -Rfv "$CURRENT_DOC_EXTRACTION_TEMP_PATH"/ "$DOC_DIR"
            else
                echo "No matched archive in $DOC_EXTRACTION_TEMP_PATH, do not apply patch for $DOC_DIR"
            fi
        fi
    fi

    if [ "$KAV_APP_PKG" != "" ]
    then
        LAST_PATCH_DEPLOYMENT_TIMESTAMP=$(get_last_patch_deployment)
        KAV_APP_PKG_TIMESTAMP=$(stat -f "%m" "$KAV_APP_PKG")
        echo "kav app pkg timestamp: $KAV_APP_PKG_TIMESTAMP, last path deployment timestamp: $LAST_PATCH_DEPLOYMENT_TIMESTAMP"

        if [[ (-e "$KAV_APP_PKG") && ($KAV_APP_PKG_TIMESTAMP > $LAST_PATCH_DEPLOYMENT_TIMESTAMP) ]]; then
            KAV_APP_EXTRACTION_TEMP_PATH=$(mktemp -d)
            echo ""
            echo "Extracting $KAV_APP_PKG into $KAV_APP_EXTRACTION_TEMP_PATH"
            tar -xzvf "$KAV_APP_PKG" -C "$KAV_APP_EXTRACTION_TEMP_PATH"
            echo "Extracted: "
            ls -la "$KAV_APP_EXTRACTION_TEMP_PATH"

    		echo ""
    		echo "Deploying application resources..."

    		KAVAPP_PATHS=$(mdfind "kMDItemCFBundleIdentifier == 'com.kaspersky.kav'" | grep -v "^/Volumes/")
    		if [ "$KAVAPP_PATHS" == "" ]
    		then
    			KAVAPP_PATHS="$DEFAULT_KAVAPP_PATH"
    		fi

    		OLD_IFS="$IFS"
    		IFS=$'\n'
    		for KAVAPP_PATH in $KAVAPP_PATHS
    		do
                echo ""

                if [ -f "$KAV_APP_EXTRACTION_TEMP_PATH/$MATCHED_ARCHIVE" ]; then
                    CURRENT_KAV_APP_EXTRACTION_TEMP_PATH=$(mktemp -d)
                    echo "Extracting application resources from $MATCHED_ARCHIVE to $CURRENT_KAV_APP_EXTRACTION_TEMP_PATH..."
                    tar -xzvf "$KAV_APP_EXTRACTION_TEMP_PATH/$MATCHED_ARCHIVE" -C "$CURRENT_KAV_APP_EXTRACTION_TEMP_PATH"

                    KAV_APP_CUR_RES_TEMP_PATH=$(mktemp -d)
                    echo ""
                    echo "Saving current app resources to ${KAV_APP_CUR_RES_TEMP_PATH}"
                    cp -rfv "${KAVAPP_PATH}/Contents/Resources" "${KAV_APP_CUR_RES_TEMP_PATH}"

                    KAV_APP_SAFARI_EXT_CUR_RES_TEMP_PATH=$(mktemp -d)
                    echo ""
                    echo "Saving current safari extension resources to ${KAV_APP_SAFARI_EXT_CUR_RES_TEMP_PATH}"
                    cp -rfv "${KAVAPP_PATH}/Contents/PlugIns/KasperskySecurity.appex/Contents/Resources" "${KAV_APP_SAFARI_EXT_CUR_RES_TEMP_PATH}"

                    echo ""
                    echo "Deleting current app"
                    rm -rfv "${KAVAPP_PATH}"

                    echo ""
                    KAV_APP_PARENT_DIR="${KAVAPP_PATH}"
                    echo "Moving ${CURRENT_KAV_APP_EXTRACTION_TEMP_PATH}/Kaspersky Anti-Virus For Mac.app to ${KAV_APP_PARENT_DIR}"
                    cp -rvf "${CURRENT_KAV_APP_EXTRACTION_TEMP_PATH}/Kaspersky Anti-Virus For Mac.app" "${KAV_APP_PARENT_DIR}"

                    
                    echo ""
                    echo "Updating app resources"
                    
                    echo ""
                    echo "Deleting ${KAVAPP_PATH}/Contents/Resources"
                    rm -rfv "${KAVAPP_PATH}/Contents/Resources"

                    echo ""
                    echo "Moving ${KAV_APP_CUR_RES_TEMP_PATH}/Resources to ${KAVAPP_PATH}/Contents"
                    mv "${KAV_APP_CUR_RES_TEMP_PATH}/Resources" "${KAVAPP_PATH}/Contents"

                    echo ""
                    echo "Copying new resources to app"
                    cp -Rfv "${CURRENT_KAV_APP_EXTRACTION_TEMP_PATH}/Kaspersky Anti-Virus For Mac.app/Contents/Resources/"* "${KAVAPP_PATH}/Contents/Resources"

                    echo ""
                    echo "Updating safari extension resources"

                    echo ""
                    echo "Deleting ${KAVAPP_PATH}/Contents/PlugIns/KasperskySecurity.appex/Contents/Resources"
                    rm -rfv "${KAVAPP_PATH}/Contents/PlugIns/KasperskySecurity.appex/Contents/Resources"

                    echo ""
                    echo "Moving ${KAV_APP_SAFARI_EXT_CUR_RES_TEMP_PATH}/Resources to ${KAVAPP_PATH}/Contents/PlugIns/KasperskySecurity.appex/Contents"
                    mv "${KAV_APP_SAFARI_EXT_CUR_RES_TEMP_PATH}/Resources" "${KAVAPP_PATH}/Contents/PlugIns/KasperskySecurity.appex/Contents"

                    echo ""
                    echo "Copying new resources to app"
                    cp -Rfv "${CURRENT_KAV_APP_EXTRACTION_TEMP_PATH}/Kaspersky Anti-Virus For Mac.app/Contents/PlugIns/KasperskySecurity.appex/Contents/Resources/"* "${KAVAPP_PATH}/Contents/PlugIns/KasperskySecurity.appex/Contents/Resources"

                    touch "$KAVAPP_PATH"
                else
                    echo "No matched archive in $KAV_APP_EXTRACTION_TEMP_PATH, do not apply patch for $KAVAPP_PATH"
                fi
    		done
    		IFS="$OLD_IFS"

    		echo ""
    		echo "Stopping application..."
    		stop_kav_app
    	fi
    else
        echo ""
        echo "KAV app pkg path is empty"
    fi

    if [ "$KAV_AGENT_PKG" != "" ]
    then
        LAST_PATCH_DEPLOYMENT_TIMESTAMP=$(get_last_patch_deployment)
        KAV_AGENT_PKG_TIMESTAMP=$(stat -f "%m" "$KAV_AGENT_PKG")
        echo "kav app pkg timestamp: $KAV_AGENT_PKG_TIMESTAMP, last path deployment timestamp: $LAST_PATCH_DEPLOYMENT_TIMESTAMP"

        if [[ (-e "$KAV_AGENT_PKG") && ($KAV_AGENT_PKG_TIMESTAMP > $LAST_PATCH_DEPLOYMENT_TIMESTAMP) ]];
    	then
            KAV_AGENT_EXTRACTION_TEMP_PATH=$(mktemp -d)
    		echo ""
    		echo "Extracting agent resources to $KAV_AGENT_EXTRACTION_TEMP_PATH..."
    		tar -xzvf "$KAV_AGENT_PKG" -C "$KAV_AGENT_EXTRACTION_TEMP_PATH"
            echo "Extracted: "
            ls -la "$KAV_AGENT_EXTRACTION_TEMP_PATH"

            echo ""
            echo "Deploying agent resources..."

            if [ -f "$KAV_AGENT_EXTRACTION_TEMP_PATH/$MATCHED_ARCHIVE" ]; then
                CURRENT_KAV_AGENT_EXTRACTION_TEMP_PATH=$(mktemp -d)
                echo "Extracting application resources from $MATCHED_ARCHIVE to $CURRENT_KAV_AGENT_EXTRACTION_TEMP_PATH..."
                tar -xzvf "$KAV_AGENT_EXTRACTION_TEMP_PATH/$MATCHED_ARCHIVE" -C "$CURRENT_KAV_AGENT_EXTRACTION_TEMP_PATH"

                KAV_AGENT_CUR_RES_TEMP_PATH=$(mktemp -d)
                echo ""
                echo "Saving current agent resources to ${KAV_AGENT_CUR_RES_TEMP_PATH}"
                cp -rfv "${KAV_AGENT_APP_PATH}/Contents/Resources" "${KAV_AGENT_CUR_RES_TEMP_PATH}"

                echo ""
                echo "Deleting current agent"
                rm -rfv "${KAV_AGENT_APP_PATH}"

                echo ""
                echo "Moving ${CURRENT_KAV_AGENT_EXTRACTION_TEMP_PATH}/Kaspersky Anti-Virus Agent.app to ${KAV_DIR}/Applications"
                cp -rvf "${CURRENT_KAV_AGENT_EXTRACTION_TEMP_PATH}/Kaspersky Anti-Virus Agent.app" "${KAV_DIR}/Applications"

                echo ""
                echo "Deleting ${KAV_AGENT_APP_PATH}/Contents/Resources"
                rm -rfv "${KAV_AGENT_APP_PATH}/Contents/Resources"

                echo ""
                echo "Moving ${KAV_AGENT_CUR_RES_TEMP_PATH}/Resources to ${KAV_AGENT_APP_PATH}/Contents"
                mv "${KAV_AGENT_CUR_RES_TEMP_PATH}/Resources" "${KAV_AGENT_APP_PATH}/Contents"

                echo ""
                echo "Copying new resources to agent"
                cp -Rfv "${CURRENT_KAV_AGENT_EXTRACTION_TEMP_PATH}/Kaspersky Anti-Virus Agent.app/Contents/Resources/"* "${KAV_AGENT_APP_PATH}/Contents/Resources"

                touch "${KAV_AGENT_APP_PATH}"
            else
                echo "No matched archive in $KAV_AGENT_EXTRACTION_TEMP_PATH, do not apply patch for $KAV_AGENT_APP_PATH"
            fi

    		echo ""
    		echo "Stopping agent..."
    		stop_kav_agent

    		if [ "$RESTART_KAVAGENT" == "1" ]
    		then
    			AGENTPID=$(ps -axwo pid,command | grep -v grep | grep "Contents/MacOS/kav_agent" | awk '{print $1}')
    			if [ "$AGENTPID" == "" ]
    			then
    				echo ""
    				echo "Restarting agent..."
    				LOGINWINDOW_RECORDS=$(ps -axwo pid,uid,command | grep -v grep | grep loginwindow)
    				for RECORD in "$LOGINWINDOW_RECORDS"
    				do
    					LOGINWINDOW_PID=$(/bin/echo -n "$RECORD" | awk '{print $1}')
    					LOGINWINDOW_UID=$(/bin/echo -n "$RECORD" | awk '{print $2}')
    					echo "Loading launch agent for uid $LOGINWINDOW_UID..."
    					launchctl asuser "$LOGINWINDOW_UID" launchctl load "$LAUNCHAGENT_KAV_PLIST"
    				done
    				echo "Kickstarting agent..."
    				touch "$KAV_AGENT_WATCHPATH"
    			fi
    		fi
    	fi
    else
        echo ""
        echo "KAV agent pkg path is empty"
    fi

    if [ "$KAV_UPDATE_PKG" != "" ]
    then
        LAST_PATCH_DEPLOYMENT_TIMESTAMP=$(get_last_patch_deployment)
        KAV_UPDATE_PKG_TIMESTAMP=$(stat -f "%m" "$KAV_UPDATE_PKG")
        echo "kav update pkg timestamp: $KAV_UPDATE_PKG_TIMESTAMP, last path deployment timestamp: $LAST_PATCH_DEPLOYMENT_TIMESTAMP"

        if [[ (-e "$KAV_UPDATE_PKG") && ($KAV_UPDATE_PKG_TIMESTAMP > $LAST_PATCH_DEPLOYMENT_TIMESTAMP) ]];
        then
            KAV_UPDATE_EXTRACTION_TEMP_PATH=$(mktemp -d)
            echo ""
            echo "Extracting update resources to $KAV_UPDATE_EXTRACTION_TEMP_PATH..."
            tar -xzvf "$KAV_UPDATE_PKG" -C "$KAV_UPDATE_EXTRACTION_TEMP_PATH"
            echo "Extracted: "
            ls -la "$KAV_UPDATE_EXTRACTION_TEMP_PATH"

            echo ""
            echo "Deploying update resources..."

            if [ -f "$KAV_UPDATE_EXTRACTION_TEMP_PATH/$MATCHED_ARCHIVE" ]; then
                CURRENT_KAV_UPDATE_EXTRACTION_TEMP_PATH=$(mktemp -d)
                echo "Extracting application resources from $MATCHED_ARCHIVE to $CURRENT_KAV_UPDATE_EXTRACTION_TEMP_PATH..."
                tar -xzvf "$KAV_UPDATE_EXTRACTION_TEMP_PATH/$MATCHED_ARCHIVE" -C "$CURRENT_KAV_UPDATE_EXTRACTION_TEMP_PATH"

                KAV_UPDATE_CUR_RES_TEMP_PATH=$(mktemp -d)
                echo ""
                echo "Saving current update resources to ${KAV_UPDATE_CUR_RES_TEMP_PATH}"
                cp -rfv "${KAV_UPDATE_APP_PATH}/Contents/Resources" "${KAV_UPDATE_CUR_RES_TEMP_PATH}"

                echo ""
                echo "Deleting current updater"
                rm -rfv "${KAV_UPDATE_APP_PATH}"

                echo ""
                echo "Moving ${CURRENT_KAV_UPDATE_EXTRACTION_TEMP_PATH}/Kaspersky Anti-Virus Update.app to ${KAV_DIR}/Applications"
                cp -rvf "${CURRENT_KAV_UPDATE_EXTRACTION_TEMP_PATH}/Kaspersky Anti-Virus Update.app" "${KAV_DIR}/Applications"

                echo ""
                echo "Deleting ${KAV_UPDATE_APP_PATH}/Contents/Resources"
                rm -rfv "${KAV_UPDATE_APP_PATH}/Contents/Resources"

                echo ""
                echo "Moving ${KAV_UPDATE_CUR_RES_TEMP_PATH}/Resources to ${KAV_UPDATE_APP_PATH}/Contents"
                mv "${KAV_UPDATE_CUR_RES_TEMP_PATH}/Resources" "${KAV_UPDATE_APP_PATH}/Contents"

                echo ""
                echo "Copying new resources to update"
                cp -Rfv "${CURRENT_KAV_UPDATE_EXTRACTION_TEMP_PATH}/Kaspersky Anti-Virus Update.app/Contents/Resources/"* "${KAV_UPDATE_APP_PATH}/Contents/Resources"

                touch "$KAV_UPDATE_APP_PATH"
            else
                echo "No matched archive in $KAV_UPDATE_EXTRACTION_TEMP_PATH, do not apply patch for $KAV_UPDATE_APP_PATH"
            fi
        fi
    else
        echo ""
        echo "KAV update pkg path is empty"
    fi

    if [ "$KAV_UNINSTALLER_PKG" != "" ]
    then
        LAST_PATCH_DEPLOYMENT_TIMESTAMP=$(get_last_patch_deployment)
        KAV_UNINSTALLER_PKG_TIMESTAMP=$(stat -f "%m" "$KAV_UNINSTALLER_PKG")
        echo "kav uninstaller pkg timestamp: $KAV_UNINSTALLER_PKG_TIMESTAMP, last path deployment timestamp: $LAST_PATCH_DEPLOYMENT_TIMESTAMP"

        if [[ (-e "$KAV_UNINSTALLER_PKG") && ($KAV_UNINSTALLER_PKG_TIMESTAMP > $LAST_PATCH_DEPLOYMENT_TIMESTAMP) ]];
        then
            KAV_UNINSTALLER_EXTRACTION_TEMP_PATH=$(mktemp -d)
            echo ""
            echo "Extracting uninstaller resources to $KAV_UNINSTALLER_EXTRACTION_TEMP_PATH..."
            tar -xzvf "$KAV_UNINSTALLER_PKG" -C "$KAV_UNINSTALLER_EXTRACTION_TEMP_PATH"
            echo "Extracted: "
            ls -la "$KAV_UNINSTALLER_EXTRACTION_TEMP_PATH"

            echo ""
            echo "Deploying uninstaller resources..."

            if [ -f "$KAV_UNINSTALLER_EXTRACTION_TEMP_PATH/$MATCHED_ARCHIVE" ]; then
                CURRENT_KAV_UNINSTALLER_EXTRACTION_TEMP_PATH=$(mktemp -d)
                echo "Extracting application resources from $MATCHED_ARCHIVE to $CURRENT_KAV_UNINSTALLER_EXTRACTION_TEMP_PATH..."
                tar -xzvf "$KAV_UNINSTALLER_EXTRACTION_TEMP_PATH/$MATCHED_ARCHIVE" -C "$CURRENT_KAV_UNINSTALLER_EXTRACTION_TEMP_PATH"

                KAV_UNINSTALLER_CUR_RES_TEMP_PATH=$(mktemp -d)
                echo ""
                echo "Saving current uninstaller resources to ${KAV_UNINSTALLER_CUR_RES_TEMP_PATH}"
                cp -rfv "${KAV_UNINSTALLER_APP_PATH}/Contents/Resources" "${KAV_UNINSTALLER_CUR_RES_TEMP_PATH}"

                echo ""
                echo "Deleting current uninstaller"
                rm -rfv "${KAV_UNINSTALLER_APP_PATH}"

                echo ""
                echo "Moving ${CURRENT_KAV_UNINSTALLER_EXTRACTION_TEMP_PATH}/Kaspersky Uninstaller.app to ${KAV_DIR}/Applications"
                cp -rvf "${CURRENT_KAV_UNINSTALLER_EXTRACTION_TEMP_PATH}/Kaspersky Uninstaller.app" "${KAV_DIR}/Applications"

                echo ""
                echo "Deleting ${KAV_UNINSTALLER_APP_PATH}/Contents/Resources"
                rm -rfv "${KAV_UNINSTALLER_APP_PATH}/Contents/Resources"

                echo ""
                echo "Moving ${KAV_UNINSTALLER_CUR_RES_TEMP_PATH}/Resources to ${KAV_UNINSTALLER_APP_PATH}/Contents"
                mv "${KAV_UNINSTALLER_CUR_RES_TEMP_PATH}/Resources" "${KAV_UNINSTALLER_APP_PATH}/Contents"

                echo ""
                echo "Copying new resources to uninstaller"
                cp -Rfv "${CURRENT_KAV_UNINSTALLER_EXTRACTION_TEMP_PATH}/Kaspersky Uninstaller.app/Contents/Resources/"* "${KAV_UNINSTALLER_APP_PATH}/Contents/Resources"

                touch "$KAV_UNINSTALLER_APP_PATH"
            else
                echo "No matched archive in $KAV_UNINSTALLER_EXTRACTION_TEMP_PATH, do not apply patch for $KAV_UNINSTALLER_APP_PATH"
            fi
        fi
    else
        echo ""
        echo "KAV uninstaller pkg path is empty"
    fi

    echo ""
    echo "Updating config.xml"

    if [ "${PRODUCT_TYPE}_${REGION_TYPE}" == "kis_INT" ];
    then
        SEARCH_RESULT=$(grep "LocalizationList.*en;ar;es-419;fr;ru;fi;tr;de;it;es;nl;da;pt;nb;cs;pl;sv;pt-PT;th;vi" "$UPDATE_CFG_TARGET")
        if [ ! -z "$SEARCH_RESULT" ];
        then
            echo "Found latest LocalizationList in kis_INT, skip updating"
        else
            echo "Did not find latest LocalizationList in kis_INT, update it"
            touch "$CONFIG_XML_CHANGES_TMP"
            echo "environment LocalizationList en;ar;es-419;fr;ru;fi;tr;de;it;es;nl;da;pt;nb;cs;pl;sv;pt-PT;th;vi" >> "$CONFIG_XML_CHANGES_TMP"
        fi
    elif [ "${PRODUCT_TYPE}_${REGION_TYPE}" == "saas_INT" ];
    then
        SEARCH_RESULT=$(grep "LocalizationList.*en;ar;es-419;fr;ru;fi;tr;de;it;es;nl;da;pt;nb;cs;pl;sv;pt-PT;th;vi" "$UPDATE_CFG_TARGET")
        if [ ! -z "$SEARCH_RESULT" ];
        then
            echo "Found latest LocalizationList in saas_INT, skip updating"
        else
            touch "$CONFIG_XML_CHANGES_TMP"
            echo "environment LocalizationList en;ar;es-419;fr;ru;fi;tr;de;it;es;nl;da;pt;nb;cs;pl;sv;pt-PT;th;vi" >> "$CONFIG_XML_CHANGES_TMP"
        fi
    else
        echo "No changes in LocalizationList"
    fi

    SEARCH_RESULT=$(grep "OSProblemLink.*osproblem" "$UPDATE_CFG_TARGET")
    if [ -z "$SEARCH_RESULT" ];
    then
        echo "Not found osproblem link, adding it"
        touch "$CONFIG_XML_CHANGES_TMP"
        echo "environment OSProblemLink https://click.kaspersky.com/?hl=[Localization]&customization=[RebrandingCode]&link=osproblem&ext_reason=[InvalidReason]&syst=[OsVersion]&pid=[productType]mac&version=[ApplicationVersion]&hotfix=[GlobalProductHotfix]" >> "$CONFIG_XML_CHANGES_TMP"
    else
        echo "No changes in OSProblemLink"
    fi

    echo "printing $CONFIG_XML_CHANGES_TMP"
    cat "$CONFIG_XML_CHANGES_TMP"

    SYSCTRLD_PID=$(ps -axwo pid,command | grep -v grep | grep "${DEFAULT_KAVAPP_PATH}/Contents/MacOS/sysextctrld.app/Contents/MacOS/sysextctrld" | awk '{print $1}')
    if [ "${SYSCTRLD_PID}" != "" ]
    then
        echo "System extension controller pid: ${SYSCTRLD_PID}"
        kill -s TERM "${SYSCTRLD_PID}"
    else
        echo "warning: Process sysextctrld not found"
    fi
else
    LAST_PATCH_DEPLOYMENT_TIMESTAMP=$(get_last_patch_deployment)

    add_system_version_compat_to_plist "/Library/LaunchDaemons/com.kaspersky.kav.kavd.plist"
    add_system_version_compat_to_plist "/Library/LaunchDaemons/com.kaspersky.sysextctrld.plist"
    add_system_version_compat_to_plist "/Library/LaunchAgents/com.kaspersky.kav.gui.plist"

    deploy_launch_agent
    
    echo ""
    echo "Last path deployment timestamp: $LAST_PATCH_DEPLOYMENT_TIMESTAMP"
fi

split_driver_version()
{
    local MAJOR=$(echo $1 | sed -n "s/\([0-9]*\).*/\1/p")
    local MINOR=$(echo $1 | sed -n "s/\([0-9]*\)\.\([0-9]*\).*/\2/p")
    local BUGFIX=$(echo $1 | sed -n "s/\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\).*/\3/p")
    local STAGE=$(echo $1 | sed -n "s/\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\)\([a-z]*\).*/\4/p")
    local BUILD=$(echo $1 | sed -n "s/\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\)\([a-z]*\)\([0-9]*\)/\5/p")
    echo "$MAJOR $MINOR $BUGFIX $STAGE $BUILD"
}

get_driver_version_component()
{
    echo "$1" | cut -f $2 -d " "
}

get_driver_version_stage_priority()
{
    local PRIORITIZED_LIST=$(echo ":d"; echo ":a"; echo ":b"; echo ":fc"; echo ":")
    echo "$PRIORITIZED_LIST" | grep -n "^:$1" | sed "s/\([0-9]*\).*/\1/"
}

compare_driver_versions()
{
    V1=$(split_driver_version $1)
    V2=$(split_driver_version $3)

    N1=$(echo "$V1" | awk '{ print NF }')
    N2=$(echo "$V2" | awk '{ print NF }')

    local N
    if [ $N1 -gt $N2 ]; then
        N=$N1
    else
        N=$N2
    fi

    for i in `seq 1 $N`; do
	local NUMBER1=$(get_driver_version_component "$V1" $i);
	local NUMBER2=$(get_driver_version_component "$V2" $i);

	if [ $i -eq 4 ]; then
	    NUMBER1=$(get_driver_version_stage_priority ${NUMBER1})
	    NUMBER2=$(get_driver_version_stage_priority ${NUMBER2})
        fi

	if [ ${NUMBER1:=0} -ne ${NUMBER2:=0} ]; then
	    [ ${NUMBER1:=0} $2 ${NUMBER2:=0} ]
	    return
	fi
    done

    [ 0 $2 0 ]
}

update_driver()
{
    [ ! -f "$5/$3" ] && echo "No $5/$3 file" && return 1

    DRIVER_REFERENCES_PATH="/Library/Application Support/Kaspersky Lab/Shared/$1.references"
    DRIVER_REFERENCES_LEGACY_PATH="$4/$1.kext/Contents/.References.plist"
    if [ "$4" == "/Library/Extensions" ] && [ -f "$DRIVER_REFERENCES_LEGACY_PATH" ] && [ ! -f "$DRIVER_REFERENCES_PATH" ]; then
	DRIVER_REFERENCES_DIR=$(dirname "$DRIVER_REFERENCES_PATH")
	mkdir -p "$DRIVER_REFERENCES_DIR"
	mv "$DRIVER_REFERENCES_LEGACY_PATH" "$DRIVER_REFERENCES_PATH" || return 1
    fi

    if [ "$4" == "/System/Library/Extensions" ] && [ -f "$DRIVER_REFERENCES_LEGACY_PATH" ]; then
	rm -rvf "$DRIVER_REFERENCES_LEGACY_PATH"
    fi

    DRIVER_PATH="$4/$1.kext"
    if [ -d "$DRIVER_PATH" ]; then
        INSTALLED_DRIVER_VERSION=$(/usr/libexec/PlistBuddy -c "Print :CFBundleVersion" "$DRIVER_PATH/Contents/Info.plist")
        echo "Installed driver version: ${INSTALLED_DRIVER_VERSION}"
        compare_driver_versions $2 -gt $INSTALLED_DRIVER_VERSION || return 1
    fi

    echo "Deploy new driver"

    rm -rvf "$DRIVER_PATH"
    tar -xzvf "$5/$3" -C "$4"
    chown -R root:wheel "$DRIVER_PATH"
    echo "Driver $1 updated to version $2"
}

MACOS_VERSION=`sw_vers -productVersion | awk -F"." '{printf "%d.%d\n", $1, $2}'`
echo "macOS version: ${MACOS_VERSION}"

version_less_than "$MACOS_VERSION" "10.16"
IS_KEXT_AVAILABLE="$?"
if [ "${IS_KEXT_AVAILABLE}" == "0" ]
then
    echo "$MACOS_VERSION >= 10.16, use system extensions"
else
    echo "$MACOS_VERSION < 10.16, use kernel extensions"

    echo "Updating drivers..."
    SHOULD_RESET_DRIVER_CACHE=0
    update_driver klif 3.6.15a58 klif.notarized.tar.gz /Library/Extensions "$DRIVERS_PKG_DIR" && SHOULD_RESET_DRIVER_CACHE=1

    if [ "$SHOULD_RESET_DRIVER_CACHE" == "1" ]; then
        echo "Reseting driver cache..."
        touch "/Library/Extensions"
        /usr/sbin/kextcache -update-volume / || (/usr/sbin/kextcache -system-prelinked-kernel && /usr/sbin/kextcache -invalidate /)
    fi
fi

chmod -R o+r "/Library/Application Support/Kaspersky Lab/KAV/Bases/"

echo "Deleting personal certificates"
rm -rfv /Library/Caches/com.kaspersky.kav/PersonalCertificates/*

echo "Deleting kav crash logs"
rm -rfv /Library/Logs/DiagnosticReports/kav_*
echo "Deleting kav_app crash logs"
rm -rfv ~/Library/Logs/DiagnosticReports/kav_app*
echo "Deleting kav_agent crash logs"
rm -rfv ~/Library/Logs/DiagnosticReports/kav_agent*
echo "Deleting appex crash logs"
rm -rfv ~/Library/Logs/DiagnosticReports/KasperskySecurity*