#! /bin/sh
##################################################################################

#. /etc/init.d/rc.conf

##################################################################################
# install results:
##################################################################################
export INSTALL_SUCCESS_NO_REBOOT=0
export INSTALL_SUCCESS_REBOOT=1
export INSTALL_WRONG_HARDWARE=2
export INSTALL_KERNEL_CHECKSUM=3
export INSTALL_FILESYSTEM_CHECKSUM=4
export INSTALL_URLADER_CHECKSUM=5
export INSTALL_OTHER_ERROR=6
export INSTALL_FIRMWARE_VERSION=7
export INSTALL_DOWNGRADE_NEEDED=8

force_update=n
for i in $* ; do
    case $i in
        -f)
            force_update=y
        ;;
    esac
done

##################################################################################
# get Kernelversion for further handling (update 2.6.19/28<->2.6.32)
##################################################################################
currKver="`uname -r`"
kversion=""
flash_update_drv_path=""
flash_update_drv_test="yes" ###neverChAngeThiSbyHand
flash_update_drv_MIPS32R2="" ###neverChAngeThiSbyHand
flash_update_allow_Kernel3x="yes" ###neverChAngeThiSbyHand
case ${currKver} in
    2.6.19*|2.6.28*|2.6.32*|2.6.39*|3.10*)
        case ${currKver} in
            2.6.19*) kversion="2.6.19.2" ;;
            2.6.28*) kversion="2.6.28" ;;
            2.6.32*) kversion="2.6.32" ;;
            2.6.39*) kversion="2.6.39" ;;
            3.10*) 
                if [ "${flash_update_allow_Kernel3x}" = "yes" ] ; then 
                    kversion="3.10" 
                else
                    echo "install: updating Kernel '${currKver}' is not supported - abort Update";
                    exit $INSTALL_FIRMWARE_VERSION
                fi
                    ;;
        esac
        # find buildin Flash Update Tool in /lib/modules
        flash_update_drv_path="`find /lib/modules -type f -name flash_update.ko`"
        if [ -z "${flash_update_drv_path}" ] ; then

            # find external Flash Update Tool in /var
            flash_update_drv_path="`if [ -f /var/flash_update_${kversion}.ko ] ; then echo /var/flash_update_${kversion}.ko ; fi`"

            #### test on external special issue Flash Update Tool in /var ####
            if [ -n "${flash_update_drv_MIPS32R2}" ] && [ "${flash_update_drv_MIPS32R2}" = "yes" ] ; then
                # find other Flash Update Tool - compatible with older Kernel's CPU Optimization 'CPU_MIPS32_R2'
                test_cpuopt_module=`find /lib/modules -type f -name led_module.ko`
                if [ -f "${test_cpuopt_module}" ] && grep -q "vermagic=[a-zA-Z0-9_ \.]*MIPS32_R2.*[0-9]BIT" ${test_cpuopt_module} ; then
                    # yes, its running an older Kernel with CPU Optimization 'CPU_MIPS32_R2'.
                    if [ -f /var/flash_update_${kversion}_MIPS32_R2.ko ] ; then 
                        # overloading drv_path
                        flash_update_drv_path="`echo /var/flash_update_${kversion}_MIPS32_R2.ko`" ; 
                    fi
                fi
            fi
            ####
        fi
        echo "install: have Kernel ${currKver} - set kversion '${kversion}' and FlashUpdateTool '${flash_update_drv_path}'";
        ;;
    *)
        echo "install: updating Kernel '${currKver}' is not supported - abort Update";
        exit $INSTALL_FIRMWARE_VERSION
        ;;
esac
if [ -n "${flash_update_drv_test}" ] && [ "${flash_update_drv_test}" = "yes" ] && [ -z "${flash_update_drv_path}" ] ; then
    # find other buildin Flash Update Tool
    echo "install: missing Flash Update Tool - abort Update.";
    exit $INSTALL_OTHER_ERROR
fi
##################################################################################
echo "install: check and install new firmware ..."
##################################################################################

need_reboot=$INSTALL_SUCCESS_NO_REBOOT
korrekt_version=0

##################################################################################
# Power LED blinken lassen
##################################################################################
/bin/update_led_on


##################################################################################
#       Die nachfolgende Installtype-Prfung darf
#       immer von der Existenz des Installtypes ausgehen! (s.o.)
#
#       ANM.: Bei alten Gerten ohne Installtype, welche mit korrekter FW geupdatet werden sollen
#       liefert die nachfolgende Installtype-Prfung via '/etc/version --install=xyz'  immer 'TRUE', 
#       da sich in /etc/version der CASE ohne default-Tag bei nichtexistentem Tag leider so verhlt.
#       Das ist bei alten FW-Versionen noch der Fall und wird hiermit toleriert.
##################################################################################
################################
# list of accepted installtypes:
################################
echo OEM=$OEM
# get annex from Kernel dep env path
if [ "${kversion}" = 24 ] ; then
    export CONFIG_ENVIRONMENT_PATH=/proc/sys/dev/adam2
else
    export CONFIG_ENVIRONMENT_PATH=/proc/sys/urlader
fi
export ANNEX=`cat ${CONFIG_ENVIRONMENT_PATH}/annex`
if [ -z "${ANNEX}" ] ; then echo ANNEX=${ANNEX} not supported ; exit $INSTALL_WRONG_HARDWARE ; fi
echo ANNEX=$ANNEX
# Fritz_Box_HW196
if [ -z "$DISABLE_Fritz_Box_HW196" ] ; then
   echo testing acceptance for device Fritz_Box_HW196 ...
   if /etc/version --install=mips34_32MB_vdsl_dect441_2eth_2geth_1ab_pots_2usb_host_wlan11n_24175 ; then
       echo device has installtype mips34_32MB_vdsl_dect441_2eth_2geth_1ab_pots_2usb_host_wlan11n_24175
           # passt der OEM ?
           if [ ! -z "${OEM}" ] ; then
               oem_found=0
               for i in  avme ; do
                   if [ "$i" = "${OEM}" ] ; then
                       echo "OK - OEM ${OEM} is supported"
                       oem_found=1
                       break
                   fi
               done
               if [ "$oem_found" = "0" ] ; then 
                   echo "OEM ${OEM} not supported"
                   exit $INSTALL_WRONG_HARDWARE
               fi
           fi
           echo OK - accept this update for device Fritz_Box_HW196 ...
           korrekt_version=1
   fi
   echo testing acceptance for device Fritz_Box_HW196 done
fi

kernel_start=0x90020000
kernel_size=32899072
filesystem_start=0x90000000
filesystem_size=0
urlader_start=0x90000000
urlader_size=131072
newFWver=06.53
flash_start=268435456
# Versioninfo:	124.06.53
# Checkpoint:	r38801
#! /bin/sh
#! /bin/sh
if [ $korrekt_version = 0 ] ; then
    echo "error: installype not korrket"
    echo "set INFO led to off (modul=7, state=1)"
    /bin/update_led_off
    exit $INSTALL_WRONG_HARDWARE # warum auch immer: fr diese Gert wird die FW abgelehnt
fi
##################################################################################
# Rcksprung nur fr die 11.01.xx verhindern
#
# FW Version Muster: xx.BB.CC  --  der Nummernkreis BB muss bereinstimmen und CC grer oder gleich sein
#
##################################################################################
currFWver=`/etc/version -v`
echo "curr: ${currFWver}  new: xx.${newFWver}"
# Version AA.BB.CC zerlegen
major_currFWver=${currFWver%%.*} # bis zum ersten Punkt
middle_currFWver=${currFWver%.*}; middle_currFWver=${middle_currFWver#*.} # dazwischen
minor_currFWver=${currFWver##*.} # ab dem letzten Punkt
echo "debug: curr: ${major_currFWver}.${middle_currFWver}.${minor_currFWver}"
middle_newFWver=${newFWver%.*}; middle_newFWver=${middle_newFWver#*.} # dazwischen
minor_newFWver=${newFWver##*.} # ab dem letzten Punkt
echo "debug: new: \"XX.${middle_newFWver}.${minor_newFWver}\""
##################################################################################
#  fhrenden Nullen beseitigen damit die Werte zur Berechnung genutzt werden
#  knnen
##################################################################################
major_currFWver=${major_currFWver##0}
middle_currFWver=${middle_currFWver##0}
minor_currFWver=${minor_currFWver##0}
major_newFWver=${major_newFWver##0}
middle_newFWver=${middle_newFWver##0}
minor_newFWver=${minor_newFWver##0}
echo "major_currFWver=$major_currFWver"
echo "middle_currFWver=$middle_currFWver"
echo "minor_currFWver=$minor_currFWver"
echo "middle_newFWver=$middle_newFWver"
echo "minor_newFWver=$minor_newFWver"
##################################################################################
# update verhindern
##################################################################################
if [ -z "${middle_currFWver}" ] || [ -z "${minor_currFWver}" ] || [ -z "${middle_newFWver}" ] || [ -z "${minor_newFWver}" ] ; then
    echo "error: could not resolve Firmwareversion"
    echo "set INFO led to off (modul=7, state=1)"
    /bin/update_led_off
    exit $INSTALL_FIRMWARE_VERSION
fi
##################################################################################
# Downgrade with factorysettings or normal update ?
##################################################################################
if [ "${force_update}" = "y" ] ; then
    echo "Force: Accept Firmware Version: xx.${newFWver} "
    echo "Force: factorysettings ..."
    ##################################################################################
    # factorysettings non-tffs
    ##################################################################################
    # TAM
    if [ -d /data ] ; then
        if [ -d /data/tam ] ; then
            rm -f /data/tam/config
            rm -f /data/tam/meta*
        fi
    fi
    # DECT (Swissvoice)
    if [ -x /bin/dectwe ] ; then
        /bin/dectwe
    fi
    ##################################################################################
    # factorysettings tffs: ID's erst ab 100 (0x64) loeschen
    ##################################################################################
    id=$((0x64))
    while [ $id -le 255 ] ; do
        echo "clear_id $id" >/proc/tffs
        id=$(($id + 1))
    done
    id=$((0x4000))
    while [ $id -le $((0x4040)) ] ; do
        echo "clear_id $id" >/proc/tffs
        id=$(($id + 1))
    done
    id=$((0x4400))
    while [ $id -le $((0x4440)) ] ; do
        echo "clear_id $id" >/proc/tffs
        id=$(($id + 1))
    done
    echo "Force: factorysettings done."
else
    echo "check Firmware Version: xx.${newFWver}"
    ##################################################################################
    #    BB (neu) < BB (aktuell) :   update rueckfrage anstossen
    #    BB (neu) = BB (aktuell) &&  CC (neu) < CC (aktuell) :   update rueckfrage anstossen
    ##################################################################################
    if [ "$middle_newFWver" -lt "$middle_currFWver" ] ; then
        echo "warning: Firmware downgrade detected"
        echo "set INFO led to off (modul=7, state=1)"
        /bin/update_led_off
        # behaviour for devices which basically are downgradable
        exit $INSTALL_DOWNGRADE_NEEDED
    else
        echo "DEBUG: $middle_newFWver >= $middle_currFWver"
    fi
    if [ "$middle_newFWver" -eq "$middle_currFWver" ] ; then
        if [ "$minor_newFWver" -lt "$minor_currFWver" ] ; then
                echo "warning: Firmware downgrade detected"
                echo "set INFO led to off (modul=7, state=1)"
                /bin/update_led_off
                # behaviour for devices which basically are downgradable
                exit $INSTALL_DOWNGRADE_NEEDED
        else
            echo "DEBUG: $minor_newFWver >= $minor_currFWver"
        fi
    else
        echo "DEBUG: $middle_newFWver > $middle_currFWver"
    fi
    echo "Accept Firmware Version: xx.${newFWver}"
fi
# next: check_files
#! /bin/sh
echo install: ${kversion} check files...
##################################################################################
# firmware Files pruefen
##################################################################################
# skip filesystem if empty
if [ -f /var/tmp/filesystem.image ] && [ $filesystem_size -ne 0 ] ; then
    if ! /var/chksum /var/tmp/filesystem.image ; then
        echo "chksum for file /var/tmp/filesystem.image failed."
        echo "set INFO led to off (modul=7, state=1)"
        /bin/update_led_off
        exit $INSTALL_FILESYSTEM_CHECKSUM
    fi
    echo chksum for file /var/tmp/filesystem.image ok
    filsystem_image_size="`ls -l /var/tmp/filesystem.image | sed -e 's/[^0-9]/#/g' | sed -e 's/#\+[0-9]\+#\+\([0-9]\+\).*/\1/'`"
    if [ "${filsystem_image_size}" -gt "${filesystem_size}" ] ; then
        echo "Size of file /var/tmp/filesystem.image bigger than MTD-Size (${filsystem_image_size} > ${filesystem_size})."
        echo "set INFO led to off (modul=7, state=1)"
        /bin/update_led_off
        exit $INSTALL_FILESYSTEM_CHECKSUM
    fi
    echo size for file /var/tmp/filesystem.image ok
fi
if [ -f /var/tmp/kernel.image ] ; then
    if ! /var/chksum /var/tmp/kernel.image ; then
        echo "chksum for file /var/tmp/kernel.image failed."
        echo "set INFO led to off (modul=7, state=1)"
        /bin/update_led_off
        exit $INSTALL_KERNEL_CHECKSUM
    fi
    echo chksum for file /var/tmp/kernel.image ok
    kernel_image_size="`ls -l /var/tmp/kernel.image | sed -e 's/[^0-9]/#/g' | sed -e 's/#\+[0-9]\+#\+\([0-9]\+\).*/\1/'`"
    if [ "${kernel_image_size}" -gt "${kernel_size}" ] ; then
        echo "Size of file /var/tmp/kernel.image bigger than MTD-Size (${kernel_image_size} > ${kernel_size})."
        echo "set INFO led to off (modul=7, state=1)"
        /bin/update_led_off
        exit $INSTALL_KERNEL_CHECKSUM
    fi
    echo size for file /var/tmp/kernel.image ok
fi
# next: prepare_update
#! /bin/sh
##################################################################################
# prepare install
##################################################################################
# do no longer overwrite/remove /var/post_install
if [ ! -f /var/post_install ] ; then
# create, if not present
  echo "#! /bin/sh" >/var/post_install
fi
# append sequence to /var/post_install
echo 'echo $0: start' >>/var/post_install
# LED- und Betriebsstundenzaehler- Demon stoppen
echo "sleep 1" >>/var/post_install
echo "killall run_clock" >>/var/post_install
echo "if ps | grep -v grep | grep -q telefon ; then killall telefon ; fi" >>/var/post_install
echo "if ps | grep -v grep | grep -q telnetd ; then killall telnetd ; fi" >>/var/post_install
# ueberfluessigen urlader-env eintrag entsorgen
if [ ${kversion} = 24 ] ; then
# echo "echo language > /proc/sys/dev/adam2/environment" >>/var/post_install
# darf fr zuknftige internationalisierung nicht mehr gelscht werden
  echo "echo skip deleting language from env" >>/var/post_install
else
# echo "echo language > /proc/sys/urlader/environment" >>/var/post_install
# darf fr zuknftige internationalisierung nicht mehr gelscht werden
  echo "echo skip deleting language from env" >>/var/post_install
echo "echo MODE=update > /dev/avm_power" >>/var/post_install
fi
# unmittelbar vor dem Flashen den Watchdog ausschalten
if [ -e /dev/watchdog ] ; then >>/var/post_install
  echo "echo \"disable\" > /dev/watchdog" >>/var/post_install
fi >>/var/post_install
# wer luft jetzt noch ?
echo "echo still running:" >>/var/post_install
echo "ps" >>/var/post_install
echo "lsmod" >>/var/post_install
echo "sleep 1" >>/var/post_install
# next: prepare_update_flash
#! /bin/sh
##################################################################################
# some tools for install
##################################################################################
kernel_update_start=0
kernel_update_len=0
name_list=""
resizejffs2=""
# resizejffs2="y"   # always resize (for debugging)
get_kernel_mtd() {
    kernel_image_size=${1}
    kernel_mtd_size=${2}
    flash_startadress=${3}     # keep this a string
    # es gibt unterschiedliche Bezeichnungen in versch. Kernelversionen
    tmp_size=`cat /proc/mtd | grep urlader | sed -n -e 's/mtd[0-9].*: \([^ ]*\) \([^ ]*\) .*/\1/p'`
    if [ -z "$tmp_size" ] ; then 
        tmp_size=`cat /proc/mtd | grep bootloader | sed -n -e 's/mtd[0-9].*: \([^ ]*\) \([^ ]*\) .*/\1/p'`
    fi
    if [ -z "$tmp_size" ] ; then
        echo ACHTUNG keine bootloader_size!
        # kernel_update_start=0 gibt einen Fehler
        return 0
    fi
    bootloader_size=0x$tmp_size
    tmp_size=`cat /proc/mtd | grep '"jffs2"' | grep -v Kernel | sed -n -e 's/mtd[0-9].*: \([^ ]*\) \([^ ]*\) .*/\1/p'`
    tmp_blksize=`cat /proc/mtd | grep '"jffs2"' | sed -n -e 's/mtd[0-9].*: [^ ]* \([^ ]*\) .*/\1/p'`
    if [ -z "$tmp_size" ] ; then tmp_size=0; fi
    if [ -z "$tmp_blksize" ] ; then tmp_blksize=0; fi
    jffs2_blksize=0x$tmp_blksize
    jffs2_size=0x$tmp_size
    Kernel_without_jffs2_size=$(($kernel_mtd_size-$jffs2_size))
    # rueckgabewert
    kernel_update_start=$(($flash_startadress + $bootloader_size))
    echo flash_startadress $3
    echo kernel_update_start $kernel_update_start
    echo bootloader_size $bootloader_size
    echo jffs2_size $jffs2_size
    echo Kernel_without_jffs2_size $Kernel_without_jffs2_size
    echo kernel_image_size $kernel_image_size
    echo kernel_mtd_size $kernel_mtd_size
    echo Kernel_Start_Add = $kernel_update_start
    echo Kernel_End_Addr = $kernel_update_start + $kernel_image_size
    echo Kernel_without_jffs2_End_Addr = $kernel_update_start + $Kernel_without_jffs2_size
    if [ $kernel_image_size -le $Kernel_without_jffs2_size ] ; then
        kernel_update_len=$Kernel_without_jffs2_size
        if [ ! "$jffs2_size" = "0x0" ] && [ ! "$jffs2_blksize" = "0x0" ] && [ "$((${Kernel_without_jffs2_size} - ${kernel_image_size}))" -gt "$(($jffs2_blksize))" ] ; then 
           if [ ! "$(($jffs2_size))" -eq "$((1*1024*1024))" ] && [ ! "$(($jffs2_size))" -eq "$((2*1024*1024))" ] ; then
              echo install: JFFS2-Image smaller than it could be - try to resize jffs2 ... free: $((${Kernel_without_jffs2_size} - ${kernel_image_size})) Bytes, Blocksize: $(($jffs2_blksize)) Bytes 
              # rueckgabewert
              resizejffs2="y"
           else
              echo install: Info: do not resize jffs2 on default-size 1M or 2M - even if there is unused space.
           fi
        fi
    else
        if [ ! "$jffs2_size" = "0x0" ] ; then 
           echo install: Kernel-Image would overlap JFFS2-Image - try to resize jffs2 or it will be deleted ... ; 
           # rueckgabewert
           resizejffs2="y"
        fi
        kernel_update_len=$kernel_mtd_size
    fi
    return 0
}
##################################################################################
# setting files to install
##################################################################################
if [ ${kversion} = 24 ] ; then
    echo install: ${kversion} setting files to install...
    if [ -f /var/tmp/kernel.image ] ; then
        crc_param=1
        x=`cat /proc/sys/dev/adam2/environment | grep jffs2_size`
        jffs2_size=${x##jffs2_size}
        if [ -z "${jffs2_size}" ] ; then jffs2_size=0; fi
        mtd1_size=0x`cat /proc/mtd | grep ^mtd1 | sed -n -e 's/mtd1: \([^ ]*\) .*/\1/p'`
        mtd1_blocksize=0x`cat /proc/mtd | grep ^mtd1 | sed -n -e 's/mtd1: [^ ]* \([^ ]*\) .*/\1/p'`
        mtd1_blocks=$(($mtd1_size / $mtd1_blocksize))
        act_kernel_size=`ls -l /var/tmp/kernel.image | sed -e 's/[^0-9]/#/g' | sed -e 's/#\+[0-9]\+#\+\([0-9]\+\).*/\1/'`
        kernel_blocks=$(($act_kernel_size / $mtd1_blocksize))
        kernel_blocks_rest=$(($act_kernel_size % $mtd1_blocksize))
        if [ $kernel_blocks_rest -gt 0 ]; then
            kernel_blocks=$(($kernel_blocks + 1))
        fi
        to_erase=$(($mtd1_blocks - $jffs2_size))
        to_erase_size=$(($to_erase * $mtd1_blocksize))
        if [ $kernel_blocks -le $to_erase ]; then
            echo "install: /var/tmp/kernel.image to mtd1 ($to_erase blocks)"
            echo "update_parameter=flash_update_file0=\"/var/tmp/kernel.image,$kernel_start,$to_erase_size,crc=${crc_param}\"" >>/var/post_install
        else
            echo "install: /var/tmp/kernel.image to mtd1"
            echo "update_parameter=flash_update_file0=\"/var/tmp/kernel.image,$kernel_start,$kernel_size,crc=${crc_param}\"" >>/var/post_install
        fi
        need_reboot=$INSTALL_SUCCESS_REBOOT
    fi
# skip filesystem if empty
    if [ -f /var/tmp/filesystem.image ] && [ $filesystem_size -ne 0 ] ; then
        echo "install: /var/tmp/filesystem.image to mtd0"
        echo "update_parameter=\"\$update_parameter flash_update_file1=\"/var/tmp/filesystem.image,$filesystem_start,$filesystem_size,crc=1\"\"" >>/var/post_install
        need_reboot=$INSTALL_SUCCESS_REBOOT
    fi
    if [ $need_reboot -eq $INSTALL_SUCCESS_REBOOT ] ; then
        echo "insmod /var/flash_update.o \$update_parameter" >>/var/post_install
    fi
else
    ###########################################
    echo install: ${kversion} getting mtd to install...
    echo install: -----------------------------------------------------
    kernel_image_size="`ls -l /var/tmp/kernel.image | sed -e 's/[^0-9]/#/g' | sed -e 's/#\+[0-9]\+#\+\([0-9]\+\).*/\1/'`"
    get_kernel_mtd ${kernel_image_size} ${kernel_size} ${flash_start}
    echo install: -----------------------------------------------------
    echo install: kernel_size=${kernel_size}
    echo install: kernel_update_start=${kernel_update_start}
    echo install: kernel_update_len=${kernel_update_len}
    if [ "${kernel_update_start}" = "0" ] ; then
        echo "install: get_kernel_mtd() failed!"
        echo "install: aborting."
        echo "set INFO led to off (modul=7, state=1)"
        /bin/update_led_off
        exit $INSTALL_URLADER_CHECKSUM
    fi
################################################################################################################
# Prüfen ob ein JFFS2 Image fuer den TAM vorhanden ist (Retten mit resize, justiert ggfs. 'kernel_update_len' )
################################################################################################################
    if [ "${resizejffs2}" = "y" ] ; then
print_console() {
    echo "$0 [$$]: +++++++++++++ $*" >/dev/console
}
tamconf_rescue() {
    ##################################################################################
    # Tam-Konfig-Retter
    ##################################################################################
    if [ -f /data/tam/config ] ; then
        if [ ! -e /var/flash/tamconf ] ; then
            ### need chardev
            tamconf_major=`grep tffs /proc/devices`
            tamconf_tffs_major=${tamconf_major%%tffs}
            if [ -z "${tamconf_tffs_major}" ] ; then echo "[tamconf_tffs nodes init] ERROR: can't get TFFS Major-ID"; fi
            mknod /var/flash/tamconf c $tamconf_tffs_major $((0x91))
        fi
        if /usr/bin/checkempty /var/flash/tamconf ; then
            echo "TAM Defaults Rescue: cat /data/tam/config > /var/flash/tamconf"
            cat /data/tam/config > /var/flash/tamconf
        fi
    fi
}
##################################################################################
# Prüfen ob ein JFFS2 Image fuer den TAM vorhanden ist (nicht das vom /nvram finden)
##################################################################################
### jffs2 retten mit mtdram (new-style) - benoetigt kernelmodul 'mtdram' und 'expr'
# set -x
jffs2save_drv=`find lib/modules/ -name mtdram.ko`
if [ -z "${jffs2save_drv}" ] ; then 
    # try to find external Tool in /var
    jffs2save_drv=`find /var/mtdram_${kversion}.ko`; 
fi
jffs2save_expr=`find . -name expr -xdev 2>/dev/null`
# check sbin in path for modprobe,rmmod 
if [ -z "`env | grep ^PATH= | grep /sbin`" ] ; then PATH=/sbin:/usr/sbin:${PATH} ; fi
# function align Returnval: init empty
jffs2save_AlignReturn_Val=""
# function align
jffs2save_Align(){
    offset=${1}
    align=${2}
    # when offset already is a multiple of align, the second modulo is required to get a padding of 0.
    remainder=`expr ${offset} % ${align}` 
    padding=`expr $((${align} - ${remainder})) % ${align}`
    new_offset=$((${offset} + ${padding}))
    # obtain large integer "return value": assign the "returnvalue" to a global variable
    jffs2save_AlignReturn_Val=${new_offset}
    return 0
}
# init assume ok
jffs2save_status=0
# init empty
jffs2save_flash_update_params=""
if test -z "$CONFIG_CERTWAVE" && [ -f "${jffs2save_drv}" ] && [ -e "${jffs2save_expr}" ] && grep -q '/data' /proc/mounts ; then
    print_console "[jffs2save] mouted JFFS filesystem found"
    print_console "[jffs2save] capabilities to save JFFS filesystem found"
    # Tam-Konfig-Retter (benoetigt zugriff auf /data)
    tamconf_rescue > /dev/console
    # re-mount /data
    print_console "[jffs2save] unmouting JFFS filesystem /data ..."
    umount /data || print_console "[jffs2save] unmouting JFFS filesystem /data failed"
    jffs2save_aktuell=/var/tmp_jffs2-aktuell
    jffs2save_mtd_aktuell=`grep '"jffs2"' /proc/mtd`
    jffs2save_mtd_aktuell=${jffs2save_mtd_aktuell%%:*}
    jffs2save_mtd_aktuell=${jffs2save_mtd_aktuell/mtd/mtdblock}
    rm -f "${jffs2save_aktuell}"; mkdir -p "${jffs2save_aktuell}";
    mount -t jffs2 /dev/${jffs2save_mtd_aktuell} ${jffs2save_aktuell} -o ro     
    if [ "$?" -ne "0" ] ; then 
        print_console "[jffs2save] re-mount /data error (${jffs2save_aktuell})" 
        jffs2save_status=1
    else
        print_console "[jffs2save] mouted JFFS filesystem ${jffs2save_aktuell}"
    fi
    # calculate sizes: new image
    jffs2save_kernel_image_size=${kernel_image_size}
    # calculate sizes: target mtd
    jffs2save_mtd=`grep '"kernel"' /proc/mtd`
    jffs2save_mtd_size=${kernel_size}
    jffs2save_mtd_erasesize=$((0x`echo ${jffs2save_mtd} | cut -d ' ' -f3`))
    # what will be left free after updating the reserved mirror area? 
    # usable_jffs2_size = whole MTD-Size from 'extra_reserved' - (jffs2save_kernel_image_size + padding)
    jffs2save_Align "${jffs2save_kernel_image_size}" "${jffs2save_mtd_erasesize}"
    jffs2save_usable_jffs2_size=$((${jffs2save_mtd_size} - ${jffs2save_AlignReturn_Val})) 
    # Offsets: Start of 'extra_reserved' is offset for programming kernel inside mtd (${kernel_update_start}); earlieast jffs2_start is offset ${kernel_update_start} + usable_jffs2_size.
    # |-----------------extra_reserved/kernel+fs--------------------------|
    # |----JFFS2------|-padding-|--------------kernel---------------------|
    # JFFS2 must not be larger as 2M (maximum defined by kernelsettings)
    if [ "${jffs2save_usable_jffs2_size}" -gt "$((2*1024*1024))" ] ; then jffs2save_usable_jffs2_size=$((2*1024*1024)); fi
    # end of kernel-image (jffs2save_kernel_image_size + padding) may leave more than 2M empty in extra_reserved, adjust.
    jffs2save_startofjffs2=$((${kernel_update_start} + ${jffs2save_mtd_size} - ${jffs2save_usable_jffs2_size}))
    print_console "[jffs2save] start of Target-JFFS2 ${jffs2save_startofjffs2}, usable Size: ${jffs2save_usable_jffs2_size} Bytes"
    if [ "`expr ${jffs2save_startofjffs2} % ${jffs2save_mtd_erasesize}`"  -ne "0" ] ; then 
        print_console "[jffs2save] error - unalinged jffs2 offset ${jffs2save_startofjffs2}" 
        jffs2save_status=1 
    fi
    # ----- next step: save 'current' jffs2 to tmp-image. available size: jffs2save_usable_jffs2_size 
    # prepare tmp-image
    if [ "`expr ${jffs2save_usable_jffs2_size} % 1024`"  -ne "0" ] || [ "`expr ${jffs2save_mtd_erasesize} % 1024`"  -ne "0" ]; then
        print_console "[jffs2save] error - mtdram size vs. jffs2 size" 
        jffs2save_status=1 
    fi
    if echo "${jffs2save_drv}" | grep -q /var/mtdram ; then 
        print_console "[jffs2save] insmod ${jffs2save_drv} total_size=$((${jffs2save_usable_jffs2_size} / 1024)) erase_size=$((${jffs2save_mtd_erasesize} / 1024))"
        insmod ${jffs2save_drv} total_size=$((${jffs2save_usable_jffs2_size} / 1024)) erase_size=$((${jffs2save_mtd_erasesize} / 1024))
        if [ "$?" -ne "0" ] ; then 
            print_console "[jffs2save] mtdram error (load)" 
            jffs2save_status=1
        fi
    else
        print_console "[jffs2save] modprobe mtdram total_size=$((${jffs2save_usable_jffs2_size} / 1024)) erase_size=$((${jffs2save_mtd_erasesize} / 1024))"
        modprobe mtdram total_size=$((${jffs2save_usable_jffs2_size} / 1024)) erase_size=$((${jffs2save_mtd_erasesize} / 1024))
        if [ "$?" -ne "0" ] ; then 
            print_console "[jffs2save] mtdram error (load)" 
            jffs2save_status=1
        fi
    fi
    jffs2save_ram_mtd=`grep '"mtdram test device"' /proc/mtd`
    jffs2save_ram_mtd=${jffs2save_ram_mtd%%:*}
    jffs2save_ram_mtd=${jffs2save_ram_mtd/mtd/mtdblock}
    if [ -z "${jffs2save_ram_mtd}" ] ; then 
        print_console "[jffs2save] mtdram error (mtd)" 
        jffs2save_status=1 
    fi
    if [ "${jffs2save_status}" -eq "0" ] ; then
        print_console "[jffs2save] create empty tmp-image (0xff)"
        # MTD mit 0xFF fuellen - z.b. 2MByte File mit 0xFF erzeugen: dd if=/dev/zero bs=1024 count=((2*1024*1024/1024)) | tr '\0' '\377'  > myfile
        dd if=/dev/zero bs=1024 count=$((${jffs2save_usable_jffs2_size}/1024)) | tr '\0' '\377'  > /dev/${jffs2save_ram_mtd}
        rm -rf /var/tmp_jffs2; mkdir -p /var/tmp_jffs2;
        mount -t jffs2 /dev/${jffs2save_ram_mtd} /var/tmp_jffs2 
        if [ "$?" -ne "0" ] ; then 
            print_console "[jffs2save] mount error empty tmp-image"
            jffs2save_status=1 
        fi
    fi
    if [ "${jffs2save_status}" -eq "0" ] ; then
        # kopiere die Daten aus dem alten JFFS2 in das neue tmp-image
        print_console "[jffs2save] copy TAM data from mouted JFFS to tmp-image"
        mkdir -p /var/tmp_jffs2/tam/rec
        if [ "$?" -ne "0" ] ; then 
            echo [jffs2save] mkdir error - passt nicht? Inhalt verwerfen;
            jffs2save_status=1 
        else
            for meta in `find ${jffs2save_aktuell}/tam -type f -name meta*`; do
                cp $meta /var/tmp_jffs2/tam
                if [ "$?" -ne "0" ]; then jffs2save_status=1; break; fi
            done
## for m in meta1 meta2 meta3 meta4; do
##     mkdir -p /var/tmp_jffs2/test_$m
## done
        fi
    fi
    if [ "$jffs2save_status" -ne "0" ] ; then 
        echo [jffs2save] copy error - passt nicht? Inhalt verwerfen;
        jffs2save_status=1 
        print_console "[jffs2save] copy mandatory TAM data to tmp-image failed - e.g. no space left?"
    else
        jffs2save_tam_optional=0
        # Optional: Eigene Ansagen, dann Nachrichten retten
        for uvp in `find ${jffs2save_aktuell}/tam -type f -name uvp*`; do
            cp "$uvp" /var/tmp_jffs2/tam
            if [ "$?" -ne "0" ]; then rm /var/tmp_jffs2/tam/${uvp##*/}; jffs2save_tam_optional=1; break; fi
        done
        # neueste Nachrichten zuerst
        for rec in `ls -1t ${jffs2save_aktuell}/tam/rec/rec.* 2&>/dev/null`; do
            if [ -f "$rec" ] ; then 
                cp "$rec" /var/tmp_jffs2/tam/rec
                if [ "$?" -ne "0" ]; then rm /var/tmp_jffs2/tam/rec/${rec##*/}; jffs2save_tam_optional=1; break; fi
            fi
        done
        if [ "${jffs2save_tam_optional}" -ne "0" ] ; then
            print_console "[jffs2save] copy TAM data to tmp-image success, but can't copy some optional recorded TAM data"
        else
            print_console "[jffs2save] copy TAM data to tmp-image success"
        fi
    fi
    # ----- next step:  copy tmp-image to jffs2-image-file
    # alles gut ?
    if [ "${jffs2save_status}" -eq "0" ] ; then
        # close tmp-image
        umount /var/tmp_jffs2 
        if [ "$?" -ne "0" ] ; then print_console "[jffs2save] umount error ready tmp-image" ; jffs2save_status=1 ; fi
        # copy tmp-image to jffs2-image-file
        dd if=/dev/${jffs2save_ram_mtd} of=/var/jffs2.bin
        if [ "$?" -ne "0" ] ; then echo copy error? Inhalt verwerfen; jffs2save_status=1; fi
    fi
    if [ "${jffs2save_status}" -eq "0" ] ; then
        # insmod flash_update.ko flash_update_file0="/var/tmp/kernel.image,0x10020000,0x1e60000,crc=1" flash_update_file1="/var/jffs2.bin,0x11e80000,0x100000"
        jffs2save_flash_update_params="flash_update_file1=\"/var/jffs2.bin,${jffs2save_startofjffs2},${jffs2save_usable_jffs2_size}\""
        print_console "[jffs2save] going to execute: ${jffs2save_flash_update_params}"
        kernel_update_len=$((${kernel_mtd_size}-${jffs2save_usable_jffs2_size}))
        print_console "[jffs2save] going to adjust: kernel_update_len=${kernel_update_len}"
    fi
    # cleanup
    print_console "[jffs2save] cleanup"
    umount /var/tmp_jffs2 &> /dev/null
    umount ${jffs2save_aktuell} &> /dev/null
    rmmod mtdram 
    if [ "${jffs2save_status}" -ne "0" ] ; then
        rm -f /var/jffs2.bin
        jffs2save_flash_update_params=""
        print_console "[jffs2save] failed"
    fi
fi
    fi #### resizejffs2
# set +x
# exit $INSTALL_SUCCESS_NO_REBOOT
    ###########################################
    echo install: ${kversion} setting files to install...
    if [ -f /var/tmp/kernel.image ] ; then
        crc_param=1
        echo "install: /var/tmp/kernel.image to start($kernel_update_start) size($kernel_update_len)"
        if [ "${resizejffs2}" = "y" ] && [ -n "${jffs2save_flash_update_params}" ]; then
            echo "update_parameter=\"flash_update_file0=\"/var/tmp/kernel.image,$kernel_update_start,$kernel_update_len,crc=${crc_param}\" ${jffs2save_flash_update_params}\"" >>/var/post_install
        else
            echo "update_parameter=flash_update_file0=\"/var/tmp/kernel.image,$kernel_update_start,$kernel_update_len,crc=${crc_param}\"" >>/var/post_install
        fi
# set +x
# exit $INSTALL_SUCCESS_NO_REBOOT
        need_reboot=$INSTALL_SUCCESS_REBOOT
    fi
#TODO: get_kernel_mtd() liefert falsche?! $filesystem_size (sollte '0' sein)- daher erstmal alles weglassen
# skip filesystem if empty
    if [ -f /var/tmp/filesystem.image ] ; then
        act_fs_size=`ls -l /var/tmp/filesystem.image | sed -e 's/[^0-9]/#/g' | sed -e 's/#\+[0-9]\+#\+\([0-9]\+\).*/\1/'`
        if [ $act_fs_size -ne 0 ] ; then
            echo "WARNING: /var/tmp/filesystem.image with size $act_fs_size"
            # it is not validated, that backupdate with filesystem.image works!
            # need_reboot=$INSTALL_SUCCESS_REBOOT
            need_reboot=$INSTALL_FILESYSTEM_CHECKSUM
        fi
    fi
    if [ $need_reboot -eq $INSTALL_SUCCESS_REBOOT ] ; then
        echo "insmod ${flash_update_drv_path} \$update_parameter" >>/var/post_install
    fi
fi
# due to append sequence add exit to prevent accidently second run.
echo "exit 0" >>/var/post_install
chmod +x /var/post_install
# next: tail
#! /bin/sh
##################################################################################
# Spezialbehandlungen - aber nur wenn bis hierhin alles gut ist!
##################################################################################
if [ $need_reboot -eq $INSTALL_SUCCESS_REBOOT ] ; then
    ##################################################################################
    # suche & entferne _alte_ persistente Debugsettings um CAPIoTCP zu starten (/var/flash/debug.cfg, /var/rc.user)
    echo "install: check for old settings ..."
    OLD_SETTINGS_FILE="#! /bin/sh major=\`grep tffs /proc/devices\` tffs_major=\${major%%tffs} telnetd -l /sbin/ar7login killall capiotcp_server sleep 5 /usr/bin/capiotcp_server -p5031 -m3 &"
    cmp_file(){
        for i in $OLD_SETTINGS_FILE; do
            if [ ! "$1" = "$i" ] ; then echo "'$1' differs from '$i' - abweichung und raus ..."; return 1; fi
            shift
        done
        if [ ! -z "$1" ] ; then echo "'$1' following last member '$i' - abweichung und raus ..."; return 1; fi
        return 0;
    }
    if [ -f /var/rc.user ] ; then
        if cmp_file `cat /var/rc.user` ; then
            echo +++ nodes 61,62 komplett entsorgen
            echo clear_id $((0x61)) >/proc/tffs
            echo clear_id $((0x62)) >/proc/tffs
            rm -rf /var/rc.user
        fi
    fi
    ##################################################################################
    # Wahlregel-Konverter
    ##################################################################################
    if [ -x /var/regelex ] && [ -e /var/flash/fx_lcr ] ; then
      case ${OEM} in
          1und1)
              if [ -f /etc/default.${Country}/fx_lcr.${OEM} ]; then
                  # nur bis Version 04.25 laufen lassen, inkompatibel mit Labor
                  if [ "$middle_currFWver" -le "4" ] && [ "$minor_currFWver" -le "25" ]; then
                      echo konvertiere Wahlregeln: ./var/regelex 2 /var/flash/fx_lcr /etc/default.${Country}/fx_lcr.${OEM} /var/flash/fx_lcr
                      /var/regelex 2 /var/flash/fx_lcr /etc/default.${Country}/fx_lcr.${OEM} /var/flash/fx_lcr 2>/dev/null
                  fi
              fi
              ;;
      esac
    fi
    ##################################################################################
    # PDefs-Konverter
    ##################################################################################
    if [ -n "${pdefs_update}" ] && [ -e "${pdefs_update}" ] && [ -x /var/provider_update.sh ] ; then
        /var/provider_update.sh ${pdefs_update}
    fi
    ##################################################################################
    # Tam-Konfig-Retter
    ##################################################################################
    if [ -f /data/tam/config ] ; then
        if [ ! -e /var/flash/tamconf ] ; then
            ### need chardev
            tamconf_major=`grep tffs /proc/devices`
            tamconf_tffs_major=${tamconf_major%%tffs}
            if [ -z "${tamconf_tffs_major}" ] ; then echo "[tamconf_tffs nodes init] ERROR: can't get TFFS Major-ID"; fi
            mknod /var/flash/tamconf c $tamconf_tffs_major $((0x91))
        fi
        if /usr/bin/checkempty /var/flash/tamconf ; then
            echo "TAM Defaults Rescue: cat /data/tam/config > /var/flash/tamconf"
            cat /data/tam/config > /var/flash/tamconf
        fi
    fi
    ##################################################################################
    # Loeschen der C+P Logs
    echo clear_id 95 >/proc/tffs
    echo clear_id 96 >/proc/tffs
fi
##################################################################################
if [ $need_reboot -eq $INSTALL_SUCCESS_REBOOT ] ; then
    echo "set INFO led to blink (modul=7, state=4)"
    /bin/update_led_on
else
    echo "set INFO led to off (modul=7, state=1)"
    /bin/update_led_off
fi
##################################################################################
#  returnwerte:  0 kein reboot,  1 reboot
##################################################################################
exit $need_reboot
##################################################################################
echo "****INSTALLSCRIPT STOPPED ON DEVICE FOR TESTING (disabling watchdog)****"
if [ -e /dev/watchdog ] ; then
    echo "disable" > /dev/watchdog
fi
if [ -f /var/run/delayed_reboot.pid ] ; then
    ## Terminate any scheduled delayed reboot from firmwarecfg-CGI
    local REBOOT_PID=`cat /var/run/delayed_reboot.pid`
    rm /var/run/delayed_reboot.pid
    if [ "$REBOOT_PID" != "" ] ; then
        kill -9 $REBOOT_PID
    fi
fi
echo "****$need_reboot****"
exit 0
##################################################################################
