Upgrade from KerOS version 3.x to 4.0 with custom liveburner

Upgrade from KerOS version 3.x to 4.0 with custom liveburner

KerOS v4.0 introduces some important modifications (new kernel, rootfsRW, hotfixing) requiring an upgrade with a liveburner when coming from KerOS v3.x firmware. This page will provide a way to do this upgrade with conservation of some elements like the configuration and reinstall some additional packages.

Introduction

A liveburner package will by default flash the eMMC content and install only the KerOS package. So any packages, data, and configurations will be lost using such upgrade package.
This upgrade will be problematic for products already on the field that need to keep a Device Management link up and running before and after the upgrade.

To solve this, this procedure will provide:

A way to backup some files (i.e. configurations) before flashing the eMMC and restore them at the end of the upgrade.
A tool to customize a liveburner in order to add some additional packages during the upgrade.

This procedure is not applicable to the 4.1 version of KerOS liveburner. More information about the supported migration scenarii is available here

Please note that an upgrade is always risky and must be tested and validated before deploying on the products on the field. We also recommend to upgrade products in small batches and not all the products in a row.

Upgrade procedure

When using this customized liveburner, the following steps are done to achieve the upgrade:

Deploy and install the customized liveburner IPK on the product.
Product will restart on the liveburner upgrade tool.
Execution of the script preinst to mount a safezone and copy the files to backup on it.
Upgrade of the KerOS system including the eMMC flash and installation of the KerOS package.
Execution of the preapps and/or postapps scripts to access to the safezone and restore/merge saved files.
Execution of the preapps script (if present) to access to the safezone and restore/merge saved files
Installation of the additional packages
Execution of the postapps script (if present)
Save packages in backup
Execution of the prereboot script (if present)
Restart on the new KerOS system.

Requirements

A desktop Linux machine (native or virtual). ⇒ It will be used to build the liveburner package.
An original KerOS liveburner 4.0 package available in the resources page: Wirnet gateways resources.
The update_liveburner_package-v4.1.0.tar.gz tool available here.

The following packages:

sudo apt-get install device-tree-compiler cpio binutils tree

Limits

Some limits are present in this upgrade mechanism:

Safezone space: 2MiB.
Additional packages max size cumulated: 20MiB.
Only Keros liveburner 4.0 is supported.

Migrations supported

The tool integrates sample scripts in the sample_scripts directory that will provide some migrations:

System configuration:
- From KerOS 3.x product: Network configuration (/etc/network directory)
- From KerOS 4.0 product: Sysupgrade configuration (except /var directory)
LoRa configuration:
- SPF to CPF v1.0 conversion
- CPF configuration
BSCC configuration (for Wanesy Management Center customers)
Secrets and OpenVPN configuration (for Wanesy Management Center customers)

Usage

Generate a custom liveburner (from a Linux machine)

Default process

First, uncompress the update_liveburner package:

#tar -xvzf update_liveburner_package-v4.1.0.tar.gz
update_liveburner.sh
extract_custom_elements.sh
show_ipk_infos.sh
functions
dumpimage
mkimage
sample_scripts/
sample_scripts/postapps
sample_scripts/preapps
sample_scripts/preinst
sample_scripts/prereboot
spftocpfconf.klk-lpbs
spftocpfconf.klk-wifc
spftocpfconf.klkgw

The package is ready to be used with some integrated migrations.

Then you can launch a generation of custom liveburner using the following command:

#./update_liveburner.sh liveburner_4.0.X_klk-lpbs-signed.ipk sample_scripts/preapps sample_scripts/postapps sample_scripts/preinst sample_scripts/prereboot
Liveburner custom-liveburner_4.0.X_klk-lpbs-signed.ipk created

Additional packages can be installed simply by adding them as arguments.

./update_liveburner.sh liveburner_4.0.2_klk-lpbs-signed.ipk sample_scripts/preapps sample_scripts/postapps sample_scripts/preinst sample_scripts/prereboot my_package.ipk

It is possible to add some information in the description of the package by adding -m my_information. This information will be added in the CONTROL file of the package that you can read using the show_ipk_infos.sh tool.

./update_liveburner.sh -m my_information liveburner_4.0.2_klk-lpbs-signed.ipk sample_scripts/preapps sample_scripts/postapps sample_scripts/preinst sample_scripts/prereboot

Advanced process with customization (experienced user)

Default upgrade will only keep the network configuration but it is possible to customize it using the preinst, preapps, postapps or prereboot scripts. Please note that some variables/mountpoints are provided:

Variable	Role	Example
`ROOTFSRW_PATH`	Root path adapted to the firmware version. For KerOS < 4.0 it will be `/user/rootfs_rw/` and for >= 4.0 version it will be `/`	`cp ${ROOTFSRW_PATH}/etc/hosts ${SAFEZONE_MOUNTPOINT}/`
`SAFEZONE_MOUNTPOINT`	The mountpoint to use to access the safezone	`cp ${ROOTFSRW_PATH}/etc/hosts ${SAFEZONE_MOUNTPOINT}/`
`/user`	The mountpoint to use to access the RW USER partiton	`cp /user/myfile.txt ${SAFEZONE_MOUNTPOINT}/`

In case of custom upgrade, please note that the management of the content of the safezone needs to be done using the scripts preinst, preapps, postapps, prereboot like detailed below.

The recommended way is at least to clean the safezone content before starting to backup your files. The only files that must be kept in the safezone are keros_config.tar.gz, upgrade_logs.tar.gz and upgrade.log.

Save

Saving files must be done using the preinst script. It will be executed before installing the new firmware. As an example, the preinst script provided will backup the network configuration files in the safezone.
To add some files, append them at the end of the script like shown in the commented example line.

File to download - preinst.sh

preinst.sh

#!/bin/sh
# Description: Script to be executed before a liveburner upgrade.
# It will mount a safezone to backup the configuration files BEFORE
# the installation of the new firmware.
 
EMMC_DEVICE="NOT_SUPPORTED"
SAFEZONE_MOUNTPOINT="/tmp/safezeone"
KEROS_CONFIGS_ARCHIVE="keros_config.tar.gz"
ROOTFSRW_PATH="/"
LOGFILE="${SAFEZONE_MOUNTPOINT}/upgrade.log"
USER_LOGFILE=".upgrade.log"
USER_LOGFILE_ARCHIVE="${SAFEZONE_MOUNTPOINT}/upgrade_logs.tar.gz"
 
# SPF
SPF_CONFILE="/user/spf/etc/global_conf.json"
SPF2_CONFILE="/user/spf2/etc/config.json"
 
# CPF
LORAD_CONFDIR="/user/etc/lorad"
LORAFWD_CONFDIR="/user/etc/lorafwd"
CPF_CONFIGS_ARCHIVE="cpf_config.tar.gz"
 
# BSCC
BSCC_CONFFILE="/user/bscc/var.xml"
 
# WMC
WMC_CONFIGS_ARCHIVE="wmc_config.tar.gz"
WMC_CONFIGS_CLIENT_OVPN="etc/openvpn/client-openvpn.conf"
WMC_CONFIGS_FILES="\
etc/hosts \
${WMC_CONFIGS_CLIENT_OVPN} \
etc/firewall.d/iptables_openvpn.rules \
"
 
fatal_error()
{
	echo "$1"
	touch /.need_reboot
	exit 1
}
 
 
detect_emmc()
{
	for i in $(seq 0 9); do
		if [ -b "/dev/mmcblk${i}" ]; then
			EMMC_DEVICE="mmcblk${i}"
			# Update RootFS RW path for system without overlayFS
			[ ${i} -eq 3 ] && ROOTFSRW_PATH="/user/rootfs_rw/"
			break
		fi
	done
 
	if [ "${EMMC_DEVICE}" == "NOT_SUPPORTED" ]; then
		fatal_error "Emmc device not found. Kernel version: ${KERNEL_VERSION}. Please fix."
	fi
}
 
# Backup the upgrade journal file
#
backup_previous_logs()
{
	if [ -f /user/${USER_LOGFILE} ]; then
		echo "Saving /user/${USER_LOGFILE}..."
		tar -cvzf ${USER_LOGFILE_ARCHIVE} -C /user ${USER_LOGFILE}
		echo "/user/${USER_LOGFILE} saved"
	fi
}
 
# Initialize (format) the safezone and mount it in ${SAFEZONE_MOUNTPOINT}
#
create_safezone()
{
	echo "Creating safezone"
	echo 0 > /sys/block/${EMMC_DEVICE}boot0/force_ro
	mkfs.ext2 -F /dev/${EMMC_DEVICE}boot0 || fatal_error "Error during safezone format"
	mkdir -p ${SAFEZONE_MOUNTPOINT}
	mount /dev/${EMMC_DEVICE}boot0 ${SAFEZONE_MOUNTPOINT} || fatal_error "Error during safezone mount"
	echo "Safezone created and ready to use"
}
 
 
# Show some information before starting the upgrade for the traces/logs.
#
get_product_description()
{
	echo "Upgrade started at: $(date '+%f')"
	echo "Installed packages:"
	cat /.update/opkg/status
}
 
 
# Backup some KerOS configuration files in the safezone.
# Only the /etc/network information are saved.
#
backup_keros_configurations()
{
	echo "Backuping KerOS configurations in safezone..."
	if [ -f ${ROOTFSRW_PATH}/etc/sysupgrade.conf ]; then
		echo "Product support sysupgrade, using it"
		(find $(sed -ne "/^[[:space:]]*$/d; /^#/d; s@^/var/@@; p" \
				/etc/sysupgrade.conf /etc/sysupgrade.d/*.conf 2>/dev/null\
				) /etc/sysupgrade.conf /etc/sysupgrade.d/*.conf \
			-type f -o -type l 2>/dev/null; \
		) | sort -u > /tmp/keros_conffiles
		tar -cvzf ${SAFEZONE_MOUNTPOINT}/${KEROS_CONFIGS_ARCHIVE} -C ${ROOTFSRW_PATH} -T /tmp/keros_conffiles
	else
		echo "Product does not support sysupgrade, backuping network"
		tar -cvzf ${SAFEZONE_MOUNTPOINT}/${KEROS_CONFIGS_ARCHIVE} -C ${ROOTFSRW_PATH} etc/network
	fi
	echo "Backup finished"
}
 
 
# Backup SPF/CPF configuration filed in safezone, if present.
#
backup_lora_configurations()
{
	local conf_found=false
	local cpf_list_files=""
 
	# SPF
	echo "Backuping SPF configurations in safezone..."
	for file_to_backup in ${SPF_CONFILE} ${SPF2_CONFILE}
	do
		if [ -f ${file_to_backup} ]; then
			echo "File ${file_to_backup} found in system. Backup it in safezone"
			cp -f ${file_to_backup} ${SAFEZONE_MOUNTPOINT}/
			conf_found=true
		fi
	done
 
	if [ ${conf_found} = true ]; then
		echo "Backup SPF finished"
	else
		echo "No SPF configuration found. Nothing done."
	fi
 
	# CPF
	echo "Backuping CPF configurations in safezone..."
	for dir_to_backup in ${LORAD_CONFDIR} ${LORAFWD_CONFDIR}
	do
		if [ -d ${dir_to_backup} ]; then
			echo "Configuration dir ${dir_to_backup} found in system. Backup it in safezone"
			cpf_list_files="${cpf_list_files} ${dir_to_backup}"
		fi
	done
 
	if [ ! -z "${cpf_list_files}" ]; then
		tar -cvzf "${SAFEZONE_MOUNTPOINT}/${CPF_CONFIGS_ARCHIVE}" -C / ${cpf_list_files}
		echo "Backup CPF finished"
	else
		echo "No CPF configuration found. Nothing done."
	fi
}
 
# Backup BSCC configuration file in safezone, if present.
#
backup_bscc_configurations()
{
	echo "Backuping BSCC configurations in safezone..."
	if [ -f ${BSCC_CONFFILE} ]; then
		echo "File ${BSCC_CONFFILE} found in system. Backup it in safezone"
		cp -f ${BSCC_CONFFILE} ${SAFEZONE_MOUNTPOINT}/
		echo "Backup BSCC finished"
	else
		echo "No BSCC configuration found. Nothing done."
	fi
 
}
 
# Backup Prove&Core SecureStorage information
#
backup_securestorage()
{
       echo "Backuping assets loaded in Prove&Core SecureStorage..."
       dd if=/dev/${EMMC_DEVICE} bs=512 skip=10240 count=32768 | gzip > ${SAFEZONE_MOUNTPOINT}/pcore_data.img.gz
       echo "Backup finished"
}
 
# Backup WMC configuration files
#
backup_wmc_configurations()
{
	echo "Backuping WMC configurations in safezone..."
	if [ -f "${ROOTFSRW_PATH}/${WMC_CONFIGS_CLIENT_OVPN}" ]; then
		tar -cvzf ${SAFEZONE_MOUNTPOINT}/${WMC_CONFIGS_ARCHIVE} -C ${ROOTFSRW_PATH} ${WMC_CONFIGS_FILES}
		echo "Backup WMC configurations finished"
	else
		echo "No WMC configurations found. Nothing done."
	fi
}
 
####################
# MAIN KEROS PART
####################
 
detect_emmc
create_safezone
backup_previous_logs
 
echo -e "\n== START of PREINST script ==\n" 2>&1 | tee ${LOGFILE}
 
get_product_description 2>&1 | tee -a ${LOGFILE}
 
# KerOS configuration
backup_keros_configurations 2>&1 | tee -a ${LOGFILE}
 
# LoRa configuration
backup_lora_configurations 2>&1 | tee -a ${LOGFILE}
 
# BSCC configuration
backup_bscc_configurations 2>&1 | tee -a ${LOGFILE}
 
# SecureStorage information
backup_securestorage 2>&1 | tee -a ${LOGFILE}
 
# WMC configuration
backup_wmc_configurations 2>&1 | tee -a ${LOGFILE}
 
 
####################
# MAIN CUSTOMER PART
####################
 
# Example:
# cp ${ROOTFSRW_PATH}/etc/hosts ${SAFEZONE_MOUNTPOINT}/
 
echo -e "\n== End of PREINST script ==\n" 2>&1 | tee -a ${LOGFILE}
sync

In the case of custom upgrade blocking problem happens during the execution of this script, it is possible to interrupt the upgrade. To do so, it is possible to use the function fatal_error in the custom part of the script like this:

cp ${ROOTFSRW_PATH}/etc/non_existant_file ${SAFEZONE_MOUNTPOINT}/ || fatal_error "Error detected! stop the upgrade!!"

In addition, customers must take care about the last command launched by the script. If it returns an error, the upgrade will also be aborted.

This script is the last chance to stop an upgrade without consequences on the system. After this script, the upgrade is started and errors in other scripts will not stop the process.

Restore

To restore, 2 ways are possible:

Restore using the preapps/postapps scripts.
Use scripts in application packages.

The first way is the more simple way. It consist of adapting the preapps/postapps scripts (like for preinst). Kerlink recommends this method.

File to download - preapps.sh

preapps.sh

#!/bin/sh
# Description: Script to be executed during a liveburner upgrade
# but before the installation of the application packages.
# It will mount the safezone and restore the files.
 
EMMC_DEVICE="NOT_SUPPORTED"
SAFEZONE_MOUNTPOINT="/tmp/safezeone"
KEROS_CONFIGS_ARCHIVE="keros_config.tar.gz"
LOGFILE="${SAFEZONE_MOUNTPOINT}/upgrade.log"
 
# CPF
CPF_CONFIGFILE="${SAFEZONE_MOUNTPOINT}/cpf_config.tar.gz"
 
# BSCC
BSCC_CONFFILE="var.xml"
 
# WMC
WMC_CONFIGS_ARCHIVE="wmc_config.tar.gz"
WMC_SYSUPGRADE_FILE="/etc/sysupgrade.d/openvpn.conf"
WMC_OPENVPN_CONFIG="/etc/openvpn/client-openvpn.conf"
WMC_FIREWALL_RULES="/etc/firewall.d/iptables_openvpn.rules"
WMC_SYSUPGRADE_FILES="${WMC_OPENVPN_CONFIG}"
 
fatal_error()
{
	echo "$1"
	exit 1
}
 
 
detect_emmc()
{
	for i in $(seq 0 9); do
		if [ -b "/dev/mmcblk${i}" ]; then
			EMMC_DEVICE="mmcblk${i}"
			break
		fi
	done
 
	if [ "${EMMC_DEVICE}" == "NOT_SUPPORTED" ]; then
		fatal_error "Emmc device not found. Kernel version: ${KERNEL_VERSION}. Please fix."
	fi
}
 
 
# Mount the safezone mountpoint in ${SAFEZONE_MOUNTPOINT}
#
mount_safezone()
{
	echo "Mounting safezone"
	echo 0 > /sys/block/${EMMC_DEVICE}boot0/force_ro
	mkdir -p ${SAFEZONE_MOUNTPOINT}
	mount /dev/${EMMC_DEVICE}boot0 ${SAFEZONE_MOUNTPOINT}
	echo "Safezone ready to use"
}
 
# Restore configuration saved in safezone by preinst in
# the new filesystem.
#
restore_keros_configurations()
{
	echo "Restoring KerOS configurations from safezone..."
	if [ -f ${SAFEZONE_MOUNTPOINT}/${KEROS_CONFIGS_ARCHIVE} ]
	then
		tar -xvzf ${SAFEZONE_MOUNTPOINT}/${KEROS_CONFIGS_ARCHIVE} -C /
		echo "Restoration finished"
	else
		echo "No restoration files in safezone. Nothing done."
	fi
}
 
 
# Adapt KerOS system configuration files restored from
# previous version. In this version, only the Connman configuration
# files are adapted.
#
adjust_keros_configurations()
{
	echo "Adjusting KerOS configurations..."
 
	for service_dir in $(find /etc/network/connman/ -type d \( -name ethernet_* -o -name wifi_* \))
	do
		local settings_file="${service_dir}/settings"
		if [ -f "${settings_file}" ]
		then
			echo "Adjust configuration in ${settings_file}"
			sed -i '/^Config\.file.*/d' "${settings_file}"
			sed -i '/^Config\.ident.*/d' "${settings_file}"
			sed -i 's/^IPv4\.method\=fixed.*/IPv4\.method\=manual/g' "${settings_file}"
		fi
	done
 
	# Report nameservers for Ethernet interface
	if [ -f /etc/network/connman/lan.config ]
	then
		local nameservers=$(awk -F "=" '$1 ~ "Nameservers" {gsub(",",";",$2);gsub(" ","",$2);print $2}' /etc/network/connman/lan.config)
		if [ ! -z "${nameservers}" ]
		then
			for service_dir in $(find /etc/network/connman/ -type d -name ethernet_*)
			do
				local settings_file="${service_dir}/settings"
				if [ -f "${settings_file}" ]
				then
					echo "Apply static nameservers ${nameservers} in ${settings_file}"
					sed -i '/^Nameservers.*/d' "${settings_file}"
					echo "Nameservers=${nameservers}" >> "${settings_file}"
				fi
			done
		fi
	fi
 
	# Allow Connman to be configured by webui/restAPI
	for cnf_file in /etc/network/connman/lan.config /etc/network/connman/wlan.config
	do
		[ -f "${cnf_file}" ] && mv "${cnf_file}" "${cnf_file}.keros3"
	done
	echo "LAN and WLAN configuration files removed"
 
	echo "Adjustements finished"
}
 
 
# Restore SPF/CPF configurations from the content in the
# safezone. In case of SPF to CPF upgrade, convert configuration.
#
restore_lora_configurations()
{
	echo "Restoring CPF configurations from safezone..."
	if [ -f "${CPF_CONFIGFILE}" ]; then
		tar -xvzf "${CPF_CONFIGFILE}" -C /
		echo "CPF configuration restored"
	else
		echo "No CPF configuration in safezone. Nothing done."
	fi
}
 
 
# Restore configuration saved in safezone by preinst in
# the new filesystem.
#
restore_bscc_configurations()
{
	echo "Restoring BSCC configurations from safezone..."
	if [ -f ${SAFEZONE_MOUNTPOINT}/${BSCC_CONFFILE} ]
	then
		mkdir -p /user/bscc/
		cp -f ${SAFEZONE_MOUNTPOINT}/${BSCC_CONFFILE} /user/bscc/
		echo "Restoration finished"
	else
		echo "No restoration files in safezone. Nothing done."
	fi
}
 
# Restore Prove&Core SecureStorage information.
restore_securestorage()
{
	echo "Restore Prove&Core SecureStorage..."
	if [ -f ${SAFEZONE_MOUNTPOINT}/pcore_data.img.gz ]; then
		gunzip -c ${SAFEZONE_MOUNTPOINT}/pcore_data.img.gz | dd of=/dev/${EMMC_DEVICE} bs=512 seek=10240
		echo "Prove&Core SecureStorage restored"
	else
		echo "No Prove&Core SecureStorage found. Nothing done."
	fi
}
 
# Adapt WMC configuration files for new firmware (if necessary)
#
adapt_wmc_configurations()
{
	echo "Adapting WMC configuration files..."
 
	# Sysupgrade
	echo "${WMC_SYSUPGRADE_FILES}" > ${WMC_SYSUPGRADE_FILE}
 
	# Tunneling Tools 3.0 modifications
	#
 
	# OpenVPN configuration
	sed -i 's/^route-up/;route-up/g' ${WMC_OPENVPN_CONFIG}
 
	# Firewall rules
	cat << EOF > ${WMC_FIREWALL_RULES}
#Firewall rules to accept OpenVPN traffic
 
*filter
-I INPUT  -m udp -p udp --sport 1194 --dport 1024:65535 -j ACCEPT
-I INPUT  -m udp -p udp --sport 30000:35000 --dport 1024:65535 -j ACCEPT
-I OUTPUT -m udp -p udp --sport 1024:65535 --dport 1194 -j ACCEPT
-I OUTPUT -m udp -p udp --sport 1024:65535 --dport 30000:35000 -j ACCEPT
COMMIT
EOF
 
	# forcibly set lns, snmp & ntp addresses
	awk -F "\t" '
		$2 == "lns" || $2 == "snmp" || $2 == "ntp.ran.com"	{ next }
		{ print }
		END {
			printf "172.17.0.1\tlns\n"
			printf "172.17.0.1\tsnmp\n"
			printf "172.17.0.1\tntp.ran.com\n"
		}' < /etc/hosts > /etc/hosts.new \
		&& mv -f /etc/hosts.new /etc/hosts
 
	echo "Done"
 
}
 
# Restore WMC configuration from safezone
restore_wmc_configurations()
{
	echo "Restoring WMC configurations from safezone..."
	if [ -f ${SAFEZONE_MOUNTPOINT}/${WMC_CONFIGS_ARCHIVE} ]
	then
		# Restore the configuration
		tar -xvzf ${SAFEZONE_MOUNTPOINT}/${WMC_CONFIGS_ARCHIVE} -C /
 
		# Adapt for KerOS 4.0
		adapt_wmc_configurations
 
		echo "Restoration finished"
	else
		echo "No restoration files in safezone. Nothing done."
	fi
}
 
####################
# MAIN KEROS PART
####################
 
detect_emmc
mount_safezone
 
echo -e "\n== Start of PREAPPS script ==\n" 2>&1 | tee -a ${LOGFILE}
 
# KerOS configuration
restore_keros_configurations 2>&1 | tee -a ${LOGFILE}
adjust_keros_configurations 2>&1 | tee -a ${LOGFILE}
 
# LoRa configuration
restore_lora_configurations 2>&1 | tee -a ${LOGFILE}
 
# BSCC configuration
restore_bscc_configurations 2>&1 | tee -a ${LOGFILE}
 
# SecureStorage information
restore_securestorage 2>&1 | tee -a ${LOGFILE}
 
# WMC configuration
restore_wmc_configurations 2>&1 | tee -a ${LOGFILE}
 
####################
# MAIN CUSTOMER PART
####################
 
# Example:
# cp -fR ${SAFEZONE_MOUNTPOINT}/*  /etc/
 
echo -e "\n== End of PREAPPS script ==\n" 2>&1 | tee -a ${LOGFILE}
sync

preapps script will be launched after the installation of the KerOS firmware but before installing any application package. postapps script will be launched after the installation of all the application packages.

The second way to restore files is to add pre/post scripts in the applications packages themselves, The drawback of this method is that application packages will be saved in backup. So the risk is to restore the files in safezone during a restoration of the product!

Install a custom liveburner

To upgrade your system, follow the software update process. Information here.

Read custom liveburner information

It is possible to extract some information about the content of a previously generated custom liveburner using the tool show_ipk_infos.sh:

# ./show_ipk_infos.sh -h
Usage: ./show_ipk_infos.sh [-h] <custom_liveburner.ipk>
	-h: this usage
	custom_liveburner.ipk: custom liveburner to extract elements from

For example:

# ./show_ipk_infos.sh custom-liveburner_4.0.2_klk-lpbs-signed.ipk
== Package content ==
 
/tmp/updateliveburner/ipk/
├── control
│   ├── control
│   ├── postinst
│   └── preinst
├── data
│   └── tmp
│       └── linux.itb
└── debian-binary
 
3 directories, 5 files
 
== Package CONTROL ==
 
Package: liveburner
Version: 4.0.2-0-g0d9f3135
Depends: keros (>= 2.0.0)
Architecture: klk_lpbs
Maintainer: Kerlink <support@kerlink.fr>
Priority: required
Section: keros
Source: http://www.kerlink.fr
Description: Kerlink OS
   Kerlink OS tunned for klk_lpbs target
   Sign information: SRK0=0xDBCE282B
   Files added:
      lorad_1.0.0-1_klk_lpbs.ipk
      lorafwd_1.0.1-1_armv7ahf-neon.ipk
      netsnmphotfix_1.0.0_klk_lpbs.ipk
      lorasnmp_v3.1_klk_lpbs.ipk
      bscc_v3.1_klk_lpbs.ipk
      preinst
      postapps
      prereboot
      preapps
 
== Burner content ==
 
/tmp/updateliveburner/ipk/data/tmp/itb/initrd/burner/
├── bscc_v3.1_klk_lpbs.ipk
├── keros.ipk
├── lorad_1.0.0-1_klk_lpbs.ipk
├── lorafwd_1.0.1-1_armv7ahf-neon.ipk
├── lorasnmp_v3.1_klk_lpbs.ipk
├── netsnmphotfix_1.0.0_klk_lpbs.ipk
├── postapps
├── preapps
├── prereboot
└── spftocpfconf
 
0 directories, 10 files

Extract content of a custom liveburner

Custom packages and scripts are integrated deeply in the liveburner. A tool is present to extract them easily:

# ./extract_custom_elements.sh -h
Usage: ./extract_custom_elements.sh [-h] <custom_liveburner.ipk>
	-h: this usage
	custom_liveburner.ipk: custom liveburner to extract elements from