#!/bin/sh
# Copyright (c) 2000-2018 Synology Inc. All rights reserved.

SS_COMMON_SCRIPT=/var/packages/SurveillanceStation/target/scripts/SurveillanceStationCommon.sh
if [ -f "${SS_COMMON_SCRIPT}" ]; then
	. ${SS_COMMON_SCRIPT}
else
	echo "$(date +'%b %e %H:%M:%S') $(basename ${SS_COMMON_SCRIPT}) not found." >> "/var/log/surveillance/surveillance.log"
	exit 0
fi

PACKAGE_DEST=$SYNOPKG_PKGDEST

# config migration
PKG_CONFIG_MIGRATE_SH="/usr/syno/bin/package_config_migrate.sh"
MOV_SYNOINFO_KEYS="ss_cms ss_vs ss_cms_slave runvisualstation"
DEL_SYNOINFO_KEYS="runsurveillance supportsurveillance surveillance_license_max ss_sync_event_player customizedsurvstation"

# pgsql db related
PGSQL_DUMP_FILE="/tmp/ss_pgsql_db.dump"
PGSQL_DUMP_FILE_TMP="${PGSQL_DUMP_FILE}.tmp"

# prev pkg backup path
SS_PKG_TMP_BASE_PATH="$SYNOPKG_PKGDEST_VOL/@sspkgprev"

# device pack
SS_DP_DIR="${SS_TARGET_DIR}/device_pack"
SS_DP_POSTINST="${SS_DP_DIR}/script/postinst"
SS_DP_DIR_DEFAULT="${SS_DP_DIR}.default"
SS_DP_TMP_PATH="${SS_PKG_TMP_BASE_PATH}/device_pack"

# local display
SS_LD_DIR="${SS_TARGET_DIR}/local_display"
SS_LD_DIR_DEFAULT="${SS_LD_DIR}.default"
SS_LD_TMP_PATH="${SS_PKG_TMP_BASE_PATH}/local_display"

#pkg install vol
SS_SYNOPKG_CONF_DIR="${SS_PACKAGE_DIR}/etc/synopkg_conf"
SS_SYNOPKG_REG_VOL_FILE="$SS_SYNOPKG_CONF_DIR/reg_volume"

UnregisterVolumeForEDS14()
{
	if [ true == $(IsDSM7) ]; then
		return
	fi

	# 6.1 & 6.2 would register volume event to stop SurveillanceStation.
	# After 6.3 this event should be unregistered since non-recording mode is ready.
	if [ true == $(IsModelEDS14) ]; then
		${SYNO_SERVICE_TOOL} --unregvol -n SurveillanceStation -t SERVICE_PKG > /dev/null 2>&1
	fi
}

RemoveOldCameraConf()
{
	SSDebugLog "Remove old camera conf."

	# Remove old camera_support.conf
	if [ -f "/usr/syno/etc/camera_support.conf" ]; then
		rm -f "/usr/syno/etc/camera_support.conf"
	fi
	if [ -f "/usr/syno/etc.defaults/camera_support.conf" ]; then
		rm -f "/usr/syno/etc.defaults/camera_support.conf"
	fi

	# Remove old camera_model.conf
	if [ -f "/usr/syno/etc/camera_model.conf" ]; then
		rm -f "/usr/syno/etc/camera_model.conf"
	fi
	if [ -f "/usr/syno/etc.defaults/camera_model.conf" ]; then
		rm -f "/usr/syno/etc.defaults/camera_model.conf"
	fi
}

PrepareSettingsConf()
{
	SSDebugLog "Update settings conf."

	# Install settings.conf
	if [ ! -f "${SS_SETTINGS_CONF}" ]; then
		cp "${PACKAGE_DEST}"/etc/settings.conf "${SS_SETTINGS_CONF}"
	fi
	mv -f "${PACKAGE_DEST}"/etc/settings.conf "${SS_PACKAGE_DIR}"/etc/settings.conf.default

	if [ -f "${PACKAGE_DEST}"/etc/checksum.conf ]; then
		cat "${PACKAGE_DEST}"/etc/checksum.conf >> "${SS_PACKAGE_DIR}"/etc/settings.conf.default
	fi

	# Write selected volume path into settings.conf
	local INTALL_SEL_SHARE_VOL_PATH="${vol_path}"
	if [ -n "${INTALL_SEL_SHARE_VOL_PATH}" ]; then
		SSDebugLog "Selected share folder volume path: ${INTALL_SEL_SHARE_VOL_PATH}"
		SetValueToConfFile "${SS_SETTINGS_CONF}" "${CONF_KEY_ACTIVE_VOLUME}" "${INTALL_SEL_SHARE_VOL_PATH}"

		if [ true == $(IsModelEDS14) ]; then
			UpdateServiceDataLink $INTALL_SEL_SHARE_VOL_PATH
		fi
	fi

	# Write direct login alias into settings.conf
	if [ "true" == "${chkSVS_Alias}" ]; then
		SetValueToConfFile "${SS_SETTINGS_CONF}" "${CONF_KEY_IS_LOGIN_BY_ALIAS}" "${chkSVS_Alias}"
		SetValueToConfFile "${SS_SETTINGS_CONF}" "${CONF_KEY_LOGIN_ALIAS}" "${strSVS_Alias}"
	fi

	# Write direct login port into settings.conf
	if [ "true" == "${chkSVS_HTTP}" ] || [ "true" == "${chkSVS_HTTPS}" ]; then
		SetValueToConfFile "${SS_SETTINGS_CONF}" "${CONF_KEY_IS_LOGIN_BY_PORT}" "${chkSVS_HTTP},${chkSVS_HTTPS}"
		SetValueToConfFile "${SS_SETTINGS_CONF}" "${CONF_KEY_LOGIN_PORT}" "${strSVS_HTTP},${strSVS_HTTPS}"
	fi

	# Upgrade conf key from CONF_KEY_SYS_DB_BKP_VOLUME to CONF_KEY_SYS_DB_BKP_PATH
	local CONF_KEY_SYS_DB_BKP_VOLUME="system_db_backup_volume"
	local BackupVolume=$(GetValueFromConfFile "${SS_SETTINGS_CONF}" "${CONF_KEY_SYS_DB_BKP_VOLUME}")
	if [ -n "${BackupVolume}" ]; then
		SetValueToConfFile	"${SS_SETTINGS_CONF}" "${CONF_KEY_SYS_DB_BKP_PATH}" "${BackupVolume}/${DEFAULT_SS_SHARE_NAME}"
		RemoveKeyFromConfFile "${SS_SETTINGS_CONF}" "${CONF_KEY_SYS_DB_BKP_VOLUME}"
	fi

	# Migrate settings
	${PKG_CONFIG_MIGRATE_SH} move "/etc/synoinfo.conf" "${SS_PACKAGE_DIR}/etc/settings.conf" "$MOV_SYNOINFO_KEYS"
	${PKG_CONFIG_MIGRATE_SH} del "/etc/synoinfo.conf" "$DEL_SYNOINFO_KEYS"

	/bin/chown "SurveillanceStation:SurveillanceStation" "${SS_SETTINGS_CONF}"
	/bin/chown "SurveillanceStation:SurveillanceStation" "${SS_PACKAGE_DIR}/etc/settings.conf.default"
}

ChangeOwnerToSS()
{
	SSDebugLog "chown to SVS for specific dirs."

	chown SurveillanceStation:SurveillanceStation ${SS_SETTINGS_CONF}
	chown -R SurveillanceStation:SurveillanceStation ${SS_PACKAGE_DIR}/scripts/backup
}

LinkResource()
{
	SSDebugLog "Start to link resource."

	chmod 777 "${SS_PACKAGE_DIR}"/target/ui/config
	rm -rf "${SS_PACKAGE_DIR}"/target/ui/scripts
	ln -sf "/usr/syno/synoman/scripts" "${SS_PACKAGE_DIR}"/target/ui/scripts
}

IsFileExist()
{
	[ -f "$1" ] && echo true || echo false
}

PrepareBackupDB()
{
	local File="$1"
	local Key="$2"
	local Name="$3"
	local BackupPath=$(GetValueFromConfFile "${File}" "${Key}")

	if [ -f "${BackupPath}/${Name}" ]; then
		echo "${BackupPath}/${Name}"
		return
	fi

	# For old backup-path
	if [ -f "${SS_SHARE_FOLDER_LINK}/${Name}" ]; then
		echo "${SS_SHARE_FOLDER_LINK}/${Name}"
		return
	elif [ -f "${SS_SERVICE_DATA_FOLDER_LINK}/${Name}" ]; then
		echo "${SS_SERVICE_DATA_FOLDER_LINK}/${Name}"
		return
	fi

	echo ""
}

RestoreDir()
{
	local DirBackup="$1"
	local DirTarget="$2"

	if [ -d "${DirBackup}" ]; then
		SSDebugLog "Restore ${DirTarget} by ${DirBackup}."
		rm -rf "${DirTarget}" > /dev/null 2>&1
		mv -f "${DirBackup}" "${DirTarget}" > /dev/null 2>&1
	fi
}

RestoreDirBackup()
{
	local BackupPath="$1"

	RestoreDir "${BackupPath}/${SS_EMAP_DIR_NAME}" "${SS_EMAP_DIR}"
	RestoreDir "${BackupPath}/${SS_RTSP_DIR_NAME}" "${SS_RTSP_DIR}"
	RestoreDir "${BackupPath}/${SS_USER_PHOTO_DIR_NAME}" "${SS_USER_PHOTO_DIR}"
	RestoreDir "${BackupPath}/${SS_DATA_DIR_NAME}" "${SS_DATA_DIR}"
}

UpgradeDB()
{
	SSDebugLog "Start to upgrade DB."

	local HasPgSqlData=$(HasSSPgsqlData)

	if [ ${USE_SQLITE} == false ]; then
		if [ false == $HasPgSqlData ]; then
			SSDebugLog "Create surveillance database."
			${PGSQL_BIN_CREATEDB}
			if [ $? != 0 ]; then
				SSDebugLog "Failed to create db."
				exit 1
			fi

			${PGSQL_BIN_PSQL} < ${SS_SYSTEM_SQL_SCRIPT} > /dev/null 2>&1
			if [ $? != 0 ]; then
				SSDebugLog "Failed to create system db."
				exit 2
			fi
			${PGSQL_BIN_PSQL} < ${SS_REC_SQL_SCRIPT} > /dev/null 2>&1
			if [ $? != 0 ]; then
				SSDebugLog "Failed to create recording db."
				exit 2
			fi
		fi
	else
		local SystemSqlPath="${SS_SYSTEM_SQL_SCRIPT}"
		local RecordingSqlPath="${SS_REC_SQL_SCRIPT}"
		local blDropUnnecessaryTables=false
		local blIsNonRecMode=false

		if [ "INSTALL" == "$SYNOPKG_PKG_STATUS" -o true == $(IsModelEDS14) ]; then
			if ! PrepareShareFolder "${vol_path}"; then
				SSDebugLog "Failed to prepare share folder while installation. Enter non-recording mode."
				SetNonRecordingMode true
			else
				SSDebugLog "Remove non-recording mode file ${SS_NON_RECORDING_FILE}."
				rm -f ${SS_NON_RECORDING_FILE}
			fi
		fi

		blIsNonRecMode=$(IsNonRecordingMode)

		# Dump pgsql db if exists
		if [ true == $HasPgSqlData ]; then
			${PGSQL_BIN_PG_DUMP} > "${PGSQL_DUMP_FILE_TMP}"
			${SS_UTILS_SCRIPT} --replace-sql-symbol-for-sqlite "${PGSQL_DUMP_FILE_TMP}" "${PGSQL_DUMP_FILE}"

			SystemSqlPath="${PGSQL_DUMP_FILE}"
			RecordingSqlPath="${PGSQL_DUMP_FILE}"
			blDropUnnecessaryTables=true

			# Backup pgsql dump file
			if ! mv -f "${PGSQL_DUMP_FILE_TMP}" "$SS_SERVICE_DATA_FOLDER_LINK/"; then
				SSDebugLog "Failed to backup pgsql"
			fi
		fi

		PrepareSystemDb $blDropUnnecessaryTables $SystemSqlPath
		PrepareRecordingDbs $blDropUnnecessaryTables $blIsNonRecMode $RecordingSqlPath
		PrepareAxisDbs $blIsNonRecMode
		PreparePOSDbs $blIsNonRecMode
		PrepareIPSpeakerDb
		PrepareSnapshotDb $blIsNonRecMode
		PrepareLogDb $blIsNonRecMode
		PrepareArchivingDb $blIsNonRecMode
		PrepareTimelapseDb $blIsNonRecMode

		FixDbMalform

		# Drop pgsql data
		if [ true == $HasPgSqlData ]; then
			${PGSQL_BIN_DROPDB}
			if [ $? != 0 ]; then
				SSDebugLog "Failed to drop pgsql surveillance db."
			fi
		fi
	fi

	${SS_SCRIPTS_DIR}/sql/sql.sh
	${SS_AXISACSCTRL_DIR}/sql/sql.sh
	${SS_TRANSACTIONS_DIR}/sql/sql.sh
}

FixDbMalform()
{
	local DbLen=${#SS_DB_LIST[@]}

	for (( i=0; i<${DbLen}; i++ ));
	do
		if [ true != $(IsDBAvailable "${SS_DB_LIST[$i]}" "${SS_TBL_LIST[$i]}") ]; then
			${SS_UTILS_SCRIPT} --fix-malform-database "${SS_DB_LIST[$i]}"
		fi
	done
}

PrepareSystemDb()
{
	local blDropUnnecessaryTables=$1
	local SystemSqlPath=$2

	if [ true == $(IsDBAvailable "${SS_SYSTEM_DB}" "${SS_SYSTEM_DB_TABLE}") ]; then
		return
	fi

	local SystemDBBackup=$(PrepareBackupDB "${SS_SETTINGS_CONF}" "${CONF_KEY_SYS_DB_BKP_PATH}" "${SS_SYSTEM_DB_NAME}")

	if [ -n "${SystemDBBackup}" ]; then
		SSDebugLog "System db backup already exist."
		mv -f "${SystemDBBackup}" "${SS_TARGET_DIR}" > /dev/null 2>&1
		RestoreDirBackup "$(/usr/bin/dirname "${SystemDBBackup}")"
	else
		RecreateDb "${SS_SYSTEM_DB}" "${SystemSqlPath}"
		if [ true == ${blDropUnnecessaryTables} ]; then
			${SS_UTILS_SCRIPT} --drop-sqlite-unnecessary-tables "${SS_SYSTEM_DB}" true
		fi
	fi

	RemoveKeyFromConfFile "${SS_SETTINGS_CONF}" "${CONF_KEY_SYS_DB_BKP_PATH}"
}

PrepareRecordingDbs()
{
	local blDropUnnecessaryTables=$1
	local blIsNonRecMode=$2
	local RecordingSqlPath=$3

	# Prepare recording db
	if [ false == ${blIsNonRecMode} -a \
		 false == $(IsDBAvailable "${SS_REC_DB}" "${SS_REC_DB_TABLE}") ]; then
		RecreateDb "${SS_REC_DB}" "${RecordingSqlPath}"

		if [ true == ${blDropUnnecessaryTables} ]; then
			${SS_UTILS_SCRIPT} --drop-sqlite-unnecessary-tables "${SS_REC_DB}" false
		fi
		rm -f "${SS_REC_CNT_DB}"
	else
		SSDebugLog "Skip create ${SS_REC_DB_NAME} since non-rec mode = ${blIsNonRecMode}, exists = $(IsFileExist ${SS_REC_DB})."
	fi

	# Prepare recording_cnt db
	if [ false == ${blIsNonRecMode} -a \
		 false == $(IsDBAvailable "${SS_REC_CNT_DB}" "${SS_REC_CNT_DB_TABLE}") ]; then
		RecreateDb "${SS_REC_CNT_DB}" "${SS_REC_CNT_SQL_SCRIPT}"
		${S82_SCRIPT} trigger-ssctl rebuild-recording-cnt
	else
		SSDebugLog "Skip create ${SS_REC_CNT_DB_NAME} since non-rec mode = ${blIsNonRecMode}, exists = $(IsFileExist ${SS_REC_CNT_DB})."
	fi
}

PrepareDb2PkgDir()
{
	local DBPath=$1
	local Table=$2
	local BkpKey=$3
	local SqlScript=$4
	local DBName="$(basename "$DBPath")"
	local BackupDB=""

	if [ false == $(IsDBAvailable "$DBPath" "$Table") ]; then
		BackupDB="$(PrepareBackupDB "$SS_SETTINGS_CONF" "$BkpKey" "$DBName")"

		if [ -n "$BackupDB" ]; then
			SSDebugLog "$DBName backup already exist."
			mv -f "$BackupDB" "$SS_TARGET_DIR" > /dev/null 2>&1
		else
			RecreateDb "$DBPath" "$SqlScript"
		fi
	fi

	RemoveKeyFromConfFile "$SS_SETTINGS_CONF" "$BkpKey"
}

PrepareDb2DataDir()
{
	local DBPath=$1
	local Table=$2
	local SqlScript=$3
	local blIsNonRecMode=$4
	local DBName="$(basename "$DBPath")"

	if [ false == $blIsNonRecMode -a \
		 false == $(IsDBAvailable "$DBPath" "$Table") ]; then
		RecreateDb "$DBPath" "$SqlScript"
	else
		SSDebugLog "Skip create $DBName since non-rec mode = $blIsNonRecMode, exists = $(IsFileExist "$DBPath")."
	fi
}

PrepareAxisDbs()
{
	local blIsNonRecMode=$1

	# Prepare axisacsctrl db
	PrepareDb2PkgDir "$SS_AXISACSCTRL_DB" "$SS_AXISACSCTRL_DB_TABLE" \
					 "$CONF_KEY_AXISACSCTRL_DB_BKP_PATH" "$SS_AXISACSCTRL_SQL_SCRIPT"

	# Prepare axisacsevtlog db
	PrepareDb2DataDir "$SS_AXISACSEVTLOG_DB" "$SS_AXISACSEVTLOG_DB_TABLE" \
					  "$SS_AXISACSEVTLOG_SQL_SCRIPT" $blIsNonRecMode
}

PreparePOSDbs()
{
	local blIsNonRecMode=$1

	# Prepare pos db
	PrepareDb2PkgDir "$SS_POS_DB" "$SS_POS_DB_TABLE" \
					 "$CONF_KEY_POS_DB_BKP_PATH" "$SS_POS_SQL_SCRIPT"

	# Prepare transactionslog db
	PrepareDb2DataDir "$SS_TRANSACTIONSLOG_DB" "$SS_TRANSACTIONSLOG_DB_TABLE" \
					  "$SS_TRANSACTIONSLOG_SQL_SCRIPT" $blIsNonRecMode
}

PrepareSnapshotDb()
{
	local blIsNonRecMode=$1

	PrepareDb2DataDir "$SS_SNAPSHOT_DB" "$SS_SNAPSHOT_DB_TABLE" \
					  "$SS_SNAPSHOT_SQL_SCRIPT" $blIsNonRecMode
}

PrepareArchivingDb()
{
	# To compatible with old ss version
	local OldDb="${SS_SERVICE_DATA_FOLDER_LINK}/${SS_ARCHIVING_DB_NAME}"

	if [ -f "$OldDb" ]; then
		SSDebugLog "$SS_ARCHIVING_DB_NAME backup already exist in data folder."
		mv -f "$OldDb" "$SS_TARGET_DIR" > /dev/null 2>&1
	fi

	PrepareDb2PkgDir "$SS_ARCHIVING_DB" "$SS_ARCHIVING_DB_TABLE" \
					 "$CONF_KEY_ARCHIVING_DB_BKP_PATH" "$SS_ARCHIVING_SQL_SCRIPT"
}

PrepareTimelapseDb()
{
	# To compatible with old ss version
	local OldDb="${SS_SERVICE_DATA_FOLDER_LINK}/${SS_TIMELAPSE_DB_NAME}"

	if [ -f "$OldDb" ]; then
		SSDebugLog "$SS_TIMELAPSE_DB_NAME backup already exist in data folder."
		mv -f "$OldDb" "$SS_TARGET_DIR" > /dev/null 2>&1
	fi

	PrepareDb2PkgDir "$SS_TIMELAPSE_DB" "$SS_TIMELAPSE_DB_TABLE" \
					 "$CONF_KEY_TIMELAPSE_DB_BKP_PATH" "$SS_TIMELAPSE_SQL_SCRIPT"
}

PrepareIPSpeakerDb()
{
	PrepareDb2PkgDir "$SS_IPSPEAKER_DB" "$SS_IPSPEAKER_DB_TABLE" \
					 "$CONF_KEY_IPSPEAKER_DB_BKP_PATH" "$SS_IPSPEAKER_SQL_SCRIPT"
}

PrepareLogDb()
{
	local blIsNonRecMode=$1

	PrepareDb2DataDir "$SS_LOG_DB" "$SS_LOG_DB_TABLE" \
					  "$SS_LOG_SQL_SCRIPT" $blIsNonRecMode

	PrepareDb2DataDir "$SS_REC_DEL_DETAIL_DB" "$SS_REC_DEL_DETAIL_DB_TABLE" \
					  "$SS_REC_DEL_DETAIL_SQL_SCRIPT" $blIsNonRecMode
}

InstallDPForSSUpgrade()
{
	# If previous device pack version is newer, use it. Else, do Upgrader with previous version
	local PreDPVer=$(GetValueFromConfFile "${SS_DP_TMP_PATH}"/conf "version")
	local PreDPBuildNum=$(echo "${PreDPVer}" | cut -d'-' -f2)

	local DPVer=$(GetValueFromConfFile "${SS_DP_DIR}"/conf "version")
	local DPBuildNum=$(echo "${DPVer}" | cut -d'-' -f2)

	if [ $PreDPBuildNum -gt $DPBuildNum ]; then
		SSDebugLog "Start to replace device pack[$DPBuildNum] with prev[$PreDPBuildNum]."
		rm -rf "${SS_DP_DIR}"
		mv -f "${SS_DP_TMP_PATH}" "${SS_TARGET_DIR}"
	fi
}

InstallDevicePack()
{
	SSDebugLog "Start to install device pack."

	if [ -d "${SS_DP_DIR_DEFAULT}" ]; then
		rm -rf "${SS_DP_DIR_DEFAULT}"
	fi
	cp -rpf "${SS_DP_DIR}" "${SS_DP_DIR_DEFAULT}"

	if [ -d "${SS_DP_TMP_PATH}" ]; then
		InstallDPForSSUpgrade
	fi
	${SS_DP_POSTINST}
}

InstallLDForSSUpgrade()
{
	# If previous local display version is newer, use it. Else, do Upgrader with previous version
	local PreLDVer=$(GetValueFromConfFile "${SS_LD_TMP_PATH}"/conf "version")
	local PreLDBuildNum=$(echo "${PreLDVer}" | cut -d'-' -f2)

	local LDVer=$(GetValueFromConfFile "${SS_LD_DIR}"/conf "version")
	local LDBuildNum=$(echo "${LDVer}" | cut -d'-' -f2)

	if [ $PreLDBuildNum -gt $LDBuildNum ]; then
		rm -rf "${SS_LD_DIR}"
		mv -f "${SS_LD_TMP_PATH}" "${SS_TARGET_DIR}"
	fi
}

InstallLocalDisplay()
{
	# Do nothing if this is not NVR platform
	if [ ! -d "${SS_LD_DIR}" ]; then
		return
	fi

	SSDebugLog "Start to install Local Display."

	if [ -d "${SS_LD_DIR_DEFAULT}" ]; then
		rm -rf "${SS_LD_DIR_DEFAULT}"
	fi

	cp -rpf "${SS_LD_DIR}" "${SS_LD_DIR_DEFAULT}"

	if [ -d "${SS_LD_TMP_PATH}" ]; then
		InstallLDForSSUpgrade
	fi
}

CleanupPrevPkgDir()
{
	rm -rf "${SS_PKG_TMP_BASE_PATH}"
}

ReplaceHelpFile()
{
	SSDebugLog "Start to replace help file."

	local help_dir=${SS_TARGET_DIR}/ui/help/
	local help_ori_str="\\\$_DSPRODUCTNAME_\\\$"
	local help_rep_str=$(sed -n 's,upnpmodelname="\([^"]*\)",\1,p' /etc.defaults/synoinfo.conf)

	egrep -nrl "\b_DSPRODUCTNAME_\b" --include "*.html" $help_dir | while read file; do
		sed -i "s/$help_ori_str/$help_rep_str/g" $file
	done

	return $?
}

UpdateRecordShareDB()
{
	${SS_RECSHARE_CTRL} "post-install-update"
}

UpdateSSDirMod()
{
	local real_dir=$(readlink ${SS_TARGET_DIR})
	chmod 777 $real_dir
}

RegPkgInstallVolume()
{
	if [ -n "$SYNOPKG_PKGDEST_VOL" ]; then
		SSDebugLog "Register pkg install volume path: [\"$SYNOPKG_PKGDEST_VOL\"]"
		[ -d "$SS_SYNOPKG_CONF_DIR" ] || mkdir "$SS_SYNOPKG_CONF_DIR"
		echo "[\"$SYNOPKG_PKGDEST_VOL\"]" > "$SS_SYNOPKG_REG_VOL_FILE"
	fi
}

main ()
{
	MakeDebugLogDir

	SSDebugLog "Start post-install."

	RegPkgInstallVolume
	UnregisterVolumeForEDS14
	RemoveOldCameraConf
	PrepareSettingsConf
	PrepareServiceDataDir

	ReplaceHelpFile
	ChangeOwnerToSS

	LinkResource
	UpgradeDB
	RunSSUpgrader

	InstallDevicePack
	InstallLocalDisplay
	CleanupPrevPkgDir

	UpdateRecordShareDB
	UpdateSSDirMod

	SSDebugLog "Finish post-install."

	exit 0
}

main "$@"
