#!/bin/bash
# -------
# File:        llxcfg-cpkg-backend
# Description: LliureX Config Packages Script to do "backend" actions on cpkgs
# Author:      Luis Garcia Gisbert <garcia_luigis@gva.es>
# 
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along 
# with this program; if not, write to the Free Software Foundation, Inc., 
# 51 Franklin St, Fifth Floor, Boston MA 02110-1301 USA
# --------

set -e

PATH="/usr/sbin:/usr/bin:/sbin:/bin"

# library
LLX_CPKGLIB="/usr/share/lliurex/llxcfg-cpkg/llxcfg-cpkg.sh"
[ -f "${LLX_CPKGLIB}" ] || exit 1
. ${LLX_CPKGLIB} 

enable_pkg(){
   pkg_exists "$1" || return 1
   if ! is_pkg_enabled "$1" 2> /dev/null ; then
      pkg="$1"
      run_directory_sync "$pkg"
      ln -s "$(cpkg_reldir "$pkg")" "$(cpkg_endir "$pkg" "$2")"
      # create required dirs
#      for d in ${CPKG_DIRS} ; do
#         mkdir -p "${d}/${pkg}"
#      done
   else
      warn_msg "Skipping already enabled config package \"$1\""
      return 1
   fi
   return 0
}

disable_pkg(){
   pkg="$1"
   pkg_exists "$1" || return 1
   is_pkg_enabled "$1" || return 1
    find "${CPKG_ENABLED}" -lname "$(cpkg_reldir "$1")" 2>/dev/null |while read FILE_NAME ; do
      rm -f "${FILE_NAME}"
   done
   # removed 'deconfigure' at disable time
   # restore files if active
#    if is_pkg_allowed "${1}" ; then
#      # TODO: if reset_pkg returns true , may be we need to restart some services ...
#      reset_pkg "${1}" || true
#   fi

   # remove required dirs
   rm -fr "$(cpkg_dir "$pkg")"
#   for d in ${CPKG_DIRS} ; do
#      [ -d "${d}/${pkg}" ] && rmdir --ignore-fail-on-non-empty "${d}/${pkg}" &> /dev/null
#   done
   # remove log
#   rm -f "${CPKG_INFO}/${pkg}.log"
   return 0
}


deny_pkg(){
   pkg_exists "$1" || return 1
   if [ ! -f "${DEFAULT_DENYFILE}" ] ; then
      touch "${DEFAULT_DENYFILE}"
   fi
   # removed 'deconfigure' at deny time
   # if pkg is active, undo changes
#   if is_pkg_allowed "${1}" ; then
#      # TODO: if reset_pkg returns true , may be we need to restart some services ...
#      reset_pkg "${1}" || true
#   fi
   if ! grep -q "^${1}$" "${DEFAULT_DENYFILE}" ; then
      ( cat "${DEFAULT_DENYFILE}"; echo "$1" ) | llxcfg-install - "${DEFAULT_DENYFILE}"
   fi
   return 0
}

allow_pkg(){
   pkg_exists "$1" || return 1
   if [ -f "${DEFAULT_DENYFILE}" ] ; then
      is_pkg_enabled "$1" || return $?
      cat "${DEFAULT_DENYFILE}" |grep -v "^${1}$" | llxcfg-install - "${DEFAULT_DENYFILE}"
   fi
   return 0
}

restart_pkg_services(){
   rcs=0
   pkg_invoke "$1" restart || rcs=$?
   return $rcs
}

run_pkg_scripts(){
   local CURPWD s i rc
   i=0
   pkg_suffix="$1"
   CTL_ACTION="$2"
   CURPWD="$(pwd)"
   while [ $i -lt ${#PKG_LIST[@]} ] ; do
      p="${PKG_LIST[$i]}"
      rc=0
      if test_pkg "$p" && [ -d "$(cpkg_dir "$p")" ] ; then
         if [ "$1" = "preconfig" ] ; then
            upgrade_test "$p" || true
         fi
         EXEC_COMMAND=""
         s="$(cpkg_dir "$p")/${pkg_suffix}"
         if [ "$1" = "postconfig" -a -s "$(cpkg_dir "$p")/${CPKG_SERVICES_FILE}" ] ; then
            EXEC_COMMAND="restart_pkg_services"
         fi
         if [ "${EXEC_COMMAND}" -o -x "${s}" ] ; then
            [ "$CTL_ACTION" = "test" ] && rc=${PKG_RC[${i}]}
            if [ "$rc" = "0" ] ; then
               cd "$(cpkg_dir "$p")"
               if [ -x "$s" ] ; then
                  ${s} || rc=$?
               fi
               if [ "${EXEC_COMMAND}" ] ; then
                  if [ $rc -eq 0 ] ; then
                     ${EXEC_COMMAND} $p || rc=$?
                  fi
               fi
               if [ $rc -eq 0 ] ; then
                  say_pkg_msg "$p" "[OK]"
               else
                  say_pkg_msg "$p" "*FAILED*"
               fi
            else
               say_pkg_msg "$p" "*not required* (no files updated)"
            fi
         fi
      fi
      [ "$CTL_ACTION" = "set" ] && PKG_RC[${i}]=$rc
      i=$(($i + 1))
   done      
   cd "${CURPWD}"
   return 0
}

say_pkg_msg(){
   local j
   j=0
   PRE="   Package $1:"
   while [ $j -lt $PKG_MSG_LEN ] ; do
      PRE="$PRE "
      j=$(($j + 1))
   done
   PRE="${PRE:0:$PKG_MSG_LEN}"
   say_msg "$PRE" "$2"
}

run_preconfig(){
   say_msg "llxcfg-cpkg: Running pre-cpkg scripts ..."
   ${SCRTOOL} "cpkg" run "pre-cpkg" || true
   say_msg "llxcfg-cpkg: BEGIN pre-configuration"
   run_pkg_scripts "preconfig" "$1"
   say_msg "llxcfg-cpkg: END pre-configuration"
}

run_postconfig(){
   say_msg "llxcfg-cpkg: BEGIN post-configuration"
   run_pkg_scripts "postconfig" "$1"
   say_msg "llxcfg-cpkg: END post-configuration"
   say_msg "llxcfg-cpkg: Running post-cpkg scripts ..."
   ${SCRTOOL} "cpkg" run "post-cpkg" || true
}

read_parameter(){
   # check line
   [ $# -ne 3 ] && return 0
   par_num=$1
   shift $1
   echo "$1"
}  

read_pkg_template(){
   pkg_name="${1}"
   install_file="${CPKG_TEMPLATES_FILE}"
   if [ ! -f ${install_file} -a -d "${DEFAULT_TEMPLATE}" ] ; then
      TEMPLATES_SOURCE=("${DEFAULT_TEMPLATE}")
      TEMPLATES_TARGET=("${DEFAULT_TARGET}")
      return 0
   else
      return 1
   fi
   TEMPLATES_SOURCE=()
   TEMPLATES_TARGET=()
   n=0
   exec 3< ${install_file}
   while read line <&3 ; do
      source_path="$(eval "read_parameter 1 ${line}")"
      target_path="$(eval "read_parameter 2 ${line}")"
      if [ "$source_path" -a "$target_path" ] ; then
         TEMPLATES_SOURCE[$n]="$source_path"
         TEMPLATES_TARGET[$n]="$target_path"
         n=$(($n + 1))
      fi
   done
   exec 3>&-
   return 0
}

read_pkg_install(){
   pkg_name="${1}"
   install_file="${CPKG_INSTALL_FILE}"
   if [ ! -f ${install_file} ] ; then
      if [ -d "${DEFAULT_SOURCE}" ] ; then
         INSTALL_SOURCES=("${DEFAULT_SOURCE}")
         INSTALL_TARGETS=("${DEFAULT_TARGET}")
         return 0
      else
         return 1
      fi
   fi
   INSTALL_SOURCES=()
   INSTALL_TARGETS=()
   n=0
   exec 3< ${install_file}
   while read line <&3 ; do
      source_path="$(eval "read_parameter 1 ${line}")"
      target_path="$(eval "read_parameter 2 ${line}")"
      if [ "$source_path" -a "$target_path" ] ; then
         INSTALL_SOURCES[$n]="$source_path"
         INSTALL_TARGETS[$n]="$target_path"
         n=$(($n + 1))
      fi
   done
   exec 3>&-
   return 0
}
escape_string(){
   echo "$1" |sed -e "s%\.%\\\.%g;s%/%\\\/%g"
}

write_pkg_log(){
   INSTALL_LOG="${CPKG_INFO}/$1.log"
   [ ! -f "${INSTALL_LOG}" ] && touch "${INSTALL_LOG}"
   TMPFILE="$(tempfile)"
   # exclude from log files in config dirs 
   sed -e "/^$(escape_string "${LCFG_ADMIN_DIR}")/d;/^$(escape_string "${LCFG_PROGS_DIR}")/d;/^$(escape_string "${LCFG_STATIC_DIR}")/d" "$2" > "$TMPFILE"
   sort -u "${INSTALL_LOG}" "$TMPFILE" |llxcfg-install - "${INSTALL_LOG}"
   rm -f "$TMPFILE"
   return 0
}

install_undo(){
   if [ -s "$1" ] ; then 
      rsync -qpog --checksum --exclude-from="$CPKG_EXCLUDE_LIST" --files-from="$1" "${CPKG_LAST_BACKUP}/" / &> /dev/null || true
   fi
}

test_dpkg_dist(){
   INSTALL_LOG="${CPKG_INFO}/$1.log"
   DPKG_EXT=".dpkg-dist"
   DPKG_OLD=".dpkg-old"
   if [ -s "$INSTALL_LOG" ] ; then
      cat "$INSTALL_LOG" |while read f; do
         if [ -f "${f}.${DPKG_EXT}" ] ; then
            rsync -qpog --checksum "${f}.${DPKG_EXT}" "${CPKG_FIRST_BACKUP}/$f" &> /dev/null || true
            rm -f "${f}.${DPKG_EXT}"
         fi
         if [ -f "${f}.${DPKG_OLD}" -a -f "$f" ] ; then
            rsync -qpog --checksum "${f}" "${CPKG_FIRST_BACKUP}/$f" &> /dev/null || true
            rm -f "${f}.${DPKG_OLD}"
         fi
      done
   fi
   return 0
}

test_user_files(){
   USER_FILE_LIST="$(cpkg_dir "$1")/$CPKG_USER_FILE"
   if [ -s "$USER_FILE_LIST" ] ; then
      cat "$INSTALL_LOG" |while read f; do
         if [ -f "${f}" ] ; then
            rsync -qpog --checksum --exclude-from="$CPKG_EXCLUDE_LIST" "${f}" "${CPKG_FIRST_BACKUP}/$f" &> /dev/null || true
         fi
      done
   fi
   return 0
}

delete_from_file(){
   diff  "$1" "$2" |sed -ne "/^< /s%^< %%p"
}

reset_pkg(){
   local rc CURPWD WPWD RESTORED_FILES
   INSTALL_LOG="${CPKG_INFO}/$1.log"
   WPWD="$(cpkg_dir "$1")"
   res_files=0
   del_files=0
   rc=0
   if [ -x "$WPWD/deconfigure" ] ; then
      CURPWD="$(pwd)"
      cd "$WPWD"
      $WPWD/deconfigure || rc=$?
      cd "$CURPWD"
   fi
   test_dpkg_dist "$1"
   test_user_files "$1"
   ignore_list=""
   if [ "$2" = "upgrade" -a -s "$WPWD/${CPKG_CONF_FILE}" -a -s "$INSTALL_LOG" ] ; then
      ignore_list="$(tempfile -p "IGN")"
      # remove "never installed files" from remove list
      combine "$WPWD/${CPKG_CONF_FILE}" and "$INSTALL_LOG" > "$ignore_list"
   fi
   if [ $rc -eq 0 -a -s "$INSTALL_LOG" ] ; then
      if [ "$ignore_list" ] ; then
         RESTORE_LIST="$(tempfile -p "LIS")"
         delete_from_file "$INSTALL_LOG" "$ignore_list" > "$RESTORE_LIST"
      else
         RESTORE_LIST="$INSTALL_LOG"
      fi
      # first, restore as files as posible
      TMP_FILE="$(tempfile -p "RES")"
      rsync -qp --checksum --files-from="$RESTORE_LIST" --exclude-from="$CPKG_EXCLUDE_LIST" --log-file="${TMP_FILE}" --log-file-format="%o %f" "${CPKG_FIRST_BACKUP}/" / &> /dev/null || true
      RESTORED_FILES="$(tempfile -p "RES")"
      log2files "${TMP_FILE}" > "$RESTORED_FILES"
      res_files=$(wc -l "${RESTORED_FILES}" |cut -f 1 -d " " )
      if [ "$VERBOSE" ] ; then
         if [ ${res_files} -gt 0 ] ; then
            echo "Restored files (package $1):"
            cat "$RESTORED_FILES"
         else
            echo "No files to restore (package $1)"
         fi
      fi
      :> "${TMP_FILE}"
      # second, remove non pre-existing files
      # (TODO: rewrite using exec to avoid potential subshell problems)
      cat "$RESTORE_LIST" |while read line; do
         [ ! -f "${CPKG_FIRST_BACKUP}/${line}" ] && rm -vf "${line}" > "${TMP_FILE}"
      done
      del_files=$(wc -l "${TMP_FILE}" |cut -f 1 -d " " )
      if [ "$VERBOSE" ] ; then
         if [ ${del_files} -gt 0 ] ; then
            echo "Deleted files (package $1):"
            sed -ne "s%.*\`\(.*\)'.*%\1%p" "${TMP_FILE}"
         else
            echo "No files to remove (package $1)"
         fi
      fi
      rm -f "$TMP_FILE"
      # last, remove backups
      cat "$RESTORED_FILES" |while read line; do
         rm -f "${CPKG_FIRST_BACKUP}/${line}"
         rm -f "${CPKG_LAST_BACKUP}/${line}"
      done
      rm -f "$RESTORED_FILES"
   fi
   num_files=$(($res_files + $del_files))
   if [ "$ignore_list" ] ; then
      cat "$ignore_list" |sort -u |llxcfg-install - "$INSTALL_LOG"
      rm -f "$ignore_list"
   else
      rm -f "$INSTALL_LOG"
   fi
   return ${num_files}
}

log2files(){
   REG_EXP="^[^[:alpha:]]\+\(send\|recv\)[[:blank:]]\+"
#   sed -ne "/^.* recv /s%^.* recv %/%p" "$1"
   sed -ne "/${REG_EXP}/s%${REG_EXP}%/%p" "$1"
}

cpkg_readfield(){
   [ -f "$2" ] && sed -ne "/^${1}:/{s%,[[:space:]]\+%,%g;s%^${1}:[[:space:]]*%%p}" "$2"
}

run_directory_sync(){
   p="$1"
   rc=0
   CDIR="$(cpkg_dir $p)/"
   mkdir -p "$CDIR"
#   rsync -a --delete "${CPKG_ORIGINAL}/$p/" "$CDIR" &>/dev/null || rc=$?
   rsync -a --delete "${CPKG_ORIGINAL}/$p/" "$CDIR"  || rc=$?
   if [ -d "$CPKG_PREOVERRIDES_DIR/$p" ] && [ $rc -eq 0 ] ; then
      rsync -a "$CPKG_PREOVERRIDES_DIR/$p/" "$CDIR" || rc=$?
   fi
   return $rc
}

cpkg_postoverrides(){
   rc=0
   p="$1"
   CDIR="$(cpkg_dir $p)/"
   mkdir -p "$CDIR"
   if [ -d "$CPKG_POSTOVERRIDES_DIR/$p" ] ; then
      rsync -a "$CPKG_POSTOVERRIDES_DIR/$p/" "$CDIR" || rc=$?
   fi
}

upgrade_test(){
      local CURPWD p rc s s0 u ut
      CURPWD="$(pwd)"
      p="$1"
      rc=0
      if test_pkg "$p" &>/dev/null ; then
         # first, purge and update run-directory
         run_directory_sync "$p" || true
         s="$(cpkg_dir $p)/${CPKG_CONTROL_FILE}"
         s0="${CPKG_INFO}/${p}.control"
         u="$(cpkg_dir $p)/upgrade"
         ut="$(cpkg_dir $p)/upgrade-test"
         if [ -f "$s" ] ; then
            if [ ! -f "$s0" ] ; then
              # new package (first run)
              cp "$s" "$s0"
            elif [ "$(cpkg_readfield "Version" "$s")" != "$(cpkg_readfield "Version" "$s0")" ] || ([ -x "$ut" ] && ${ut} ) ; then
               # ok, it's not a new package and has been upgraded
               if [ -x  "$u" ] ; then
                  cd "$(cpkg_dir $p)"
                  say_pkg_msg "$p" "Version upgrade: Running upgrade script ..."
                  ${u} || rc=$?
               fi
               if [ $rc -eq 0 ] ; then
                  if echo ",$(cpkg_readfield "Upgrade-actions" "$s")," |grep -q ",deconfigure," ; then
                     say_pkg_msg "$p" "Version upgrade: Deconfiguring cpkg ..."
                     reset_pkg "$p" "upgrade" &>/dev/null || true
                  fi
               fi
               cp "$s" "$s0"   
            fi
         fi
      else
         rc=1
      fi
      cd "$CURPWD"
      return $rc
}

garbage_removal(){
   local CP_FAILED INSTALLED_FILES LOG_FILE DELETED_FILES RM_FAILED PKG_NAME
   CP_FAILED="$(find "$CPKG_TMP" -type f -name "${CPKG_CP_PREFIX}*")"
   INSTALLED_FILES=$(tempfile -p "INS")
   for LOG_FILE in ${CP_FAILED} ; do
     log2files "${LOG_FILE}" > "${INSTALLED_FILES}"
     install_undo "${INSTALLED_FILES}"
     rm -f "${LOG_FILE}"
   done
   rm -f "${INSTALLED_FILES}"

   DELETED_FILES=$(tempfile -p "DEL")
   RM_FAILED="$(find "$CPKG_TMP" -type f -name "${CPKG_RM_PREFIX}*")"
   for LOG_FILE in ${RM_FAILED} ; do
      sed -e "s%.*\`\(.*\)'.*%\1%" "${LOG_FILE}" > "${DELETED_FILES}"
      install_undo "${DELETED_FILES}"
      rm -f "${LOG_FILE}"
   done
   rm -f "${DELETED_FILES}"
   # search for removed cpkgs ...
   # get list of cpkgs in the run (info) directory, and 
   # check the correponding directory in the installation path
   find "$CPKG_INFO" -maxdepth 1 -mindepth 1 -type d -printf "%P\n" |while read PKG_NAME ; do
      if [ ! -d "${CPKG_ORIGINAL}/${PKG_NAME}" ] ; then
         say_msg "${PKG_NAME} has been removed. Reverting changes ..."
         # the cpackage has been removed, so ... 
         # revert it:
         reset_pkg "$PKG_NAME" || true
         # remove run directory
         rm -rf "$(cpkg_dir "$PKG_NAME")"
         # remove copy of control file
         rm -f "${CPKG_INFO}/${PKG_NAME}.control"
      fi
   done
   return 0
}

fix_dirname(){
   echo "$1" |sed -e "s%/*$%/%"
}

install_files(){
   local COPY_LIST DIR_LIST D F FILE_TYPE FILE_TYPE_LIST
   SOURCE_DIR="$(fix_dirname "$1")"
   TARGET_DIR="$2"
   LOG_FILE=$(tempfile -p "$CPKG_CP_PREFIX" -d "$CPKG_TMP")
   INSTALLED_FILES=$(tempfile -p "INS")
   FILE_TYPE_LIST="f l"
   rc=0
   if [ -d "${SOURCE_DIR}" ] ; then
      COPY_LIST="$(tempfile -p "CP")"
      DIR_LIST="$(tempfile -p "DL")"
#      find "${SOURCE_DIR}" -mindepth 1 -maxdepth 1 -printf "%P\n" > "$COPY_LIST"
#      find "${SOURCE_DIR}" -mindepth 1 -xtype f -printf "%P\n" > "$COPY_LIST"
      :> "$COPY_LIST"
      for FILE_TYPE in $FILE_TYPE_LIST ; do
         find "${SOURCE_DIR}" -mindepth 1 -type $FILE_TYPE -printf "%P\n" >> "$COPY_LIST"
      done
      find "${SOURCE_DIR}" -mindepth 1 -xtype d -printf "%P\n" > "$DIR_LIST"
#      find "${SOURCE_DIR}" -mindepth 1 -xtype d -printf "%u:%g:%m:%P\n" |sort -t : -k 4 > "$DIR_LIST"
      # add only INEXISTENTS dirs to COPY_LIST
      cat "$DIR_LIST" |while read D; do
         [ -d "/${D}/" ] || fix_dirname "${D}" >> "$COPY_LIST"
      done
      rm -f "$DIR_LIST"
      rsync -qrlpogR --no-implied-dirs --ignore-existing --exclude-from="$CPKG_EXCLUDE_LIST" --files-from="${COPY_LIST}" --backup --backup-dir="${CPKG_LAST_BACKUP}/" --checksum --log-file="${LOG_FILE}" --log-file-format="%o %f" "${SOURCE_DIR}" "${TARGET_DIR}" &> /dev/null || rc=$?
      rsync -qrlog --files-from="${COPY_LIST}" --exclude-from="$CPKG_EXCLUDE_LIST" --backup --backup-dir="${CPKG_LAST_BACKUP}/" --checksum --log-file="${LOG_FILE}" --log-file-format="%o %f" "${SOURCE_DIR}" "${TARGET_DIR}" &> /dev/null || rc=$?
      rm -f "${COPY_LIST}"
   elif [ -e "${SOURCE_DIR}" ] ; then
      rsync -qlpog --exclude-from="$CPKG_EXCLUDE_LIST" --ignore-existing --backup --backup-dir="${CPKG_LAST_BACKUP}/" --checksum --log-file="${LOG_FILE}" --log-file-format="%o %f" "${SOURCE_DIR}" "${TARGET_DIR}" &> /dev/null || rc=$?
      rsync -qlog --exclude-from="$CPKG_EXCLUDE_LIST" --backup --backup-dir="${CPKG_LAST_BACKUP}/" --checksum --log-file="${LOG_FILE}" --log-file-format="%o %f" "${SOURCE_DIR}" "${TARGET_DIR}" &> /dev/null || rc=$?
   fi
   log2files "${LOG_FILE}" > "${INSTALLED_FILES}"
   if [ $rc -ne 0 ] ; then
      install_undo "${INSTALLED_FILES}"
   else
      NEW_FILES=$(wc -l "${INSTALLED_FILES}" |cut -f 1 -d " " )
      PKG_UPDATED_FILES=$(($PKG_UPDATED_FILES + $NEW_FILES))
      # test first backup
      rsync -qpog --exclude-from="$CPKG_EXCLUDE_LIST" --files-from="${INSTALLED_FILES}" --ignore-existing "${CPKG_LAST_BACKUP}/" "${CPKG_FIRST_BACKUP}/" &> /dev/null || true
      write_pkg_log "$pkg_name" "${INSTALLED_FILES}"
   fi
   rm -f "${LOG_FILE}"
   rm -f "${INSTALLED_FILES}"
   return 0
}

install_pkg_skel(){
      local i
      pkg_name="${1}"
      test_dpkg_dist "$pkg_name"
      pdir="$(cpkg_dir $pkg_name)"
      if [ -d "$pdir" ] ; then
         cpkg_postoverrides "$pkg_name"
         cd "$pdir"
         # delete
         remove_file="remove.list"
         if [ -f "$remove_file" ] ; then
            LOG_FILE=$(tempfile -p "$CPKG_RM_PREFIX" -d "$CPKG_TMP")
            rsync -qpog --exclude-from="$CPKG_EXCLUDE_LIST" --files-from="$remove_file" / "${CPKG_LAST_BACKUP}/"  &> /dev/null || true
            # test first backup
            rsync -qpog --files-from="${remove_file}" --exclude-from="$CPKG_EXCLUDE_LIST" --ignore-existing "${CPKG_LAST_BACKUP}/" "${CPKG_FIRST_BACKUP}/" &> /dev/null || true
            :> "${LOG_FILE}"
            cat "$remove_file" |while read f ; do
               rm -fv "$f" >> "${LOG_FILE}" || true
            done
            NEW_FILES=$(wc -l "${LOG_FILE}" |cut -f 1 -d " " )
            PKG_UPDATED_FILES=$(($PKG_UPDATED_FILES + $NEW_FILES))
            write_pkg_log "$pkg_name" "${remove_file}"
            rm -f "${LOG_FILE}"
         fi
         # install skel
         if read_pkg_install "${pkg_name}" ; then
            i=0
            while [ $i -lt ${#INSTALL_SOURCES[@]} ] ; do
               install_files "${INSTALL_SOURCES[i]}" "${INSTALL_TARGETS[i]}"
               i=$(($i +1))
            done
         fi
         # templates
         if read_pkg_template "${pkg_name}" ; then
            TMP_DIR="$(mktemp -d)"
            i=0
            while [ $i -lt ${#TEMPLATES_SOURCE[@]} ] ; do
               if [ -d "${TEMPLATES_SOURCE[i]}" -a -d "${TEMPLATES_TARGET[i]}" ] ; then
                  if rsync -aqx "${TEMPLATES_SOURCE[i]}/" "${TMP_DIR}/"  &>/dev/null ; then
                     (cd "${TMP_DIR}"; find ./ -xtype f -printf "%P\n" )|while read TMP_FILE ; do
                        rc=0
                        llxcfg-template "${TMP_DIR}/${TMP_FILE}" |sponge "${TMP_DIR}/${TMP_FILE}" &>/dev/null || rc=$?
                        [ $rc -ne 0 ] && rm -f "${TMP_DIR}/${TMP_FILE}"
                     done
                  fi
                  install_files "${TMP_DIR}" "${TEMPLATES_TARGET[i]}"
               fi
               i=$(($i +1))
            done
            rm -fr "${TMP_DIR}"
         fi
      fi
}

install_skel(){
   local n CURPWD
   say_msg "llxcfg-cpkg: BEGIN skel-installation"
   n=0
   CURPWD="$(pwd)"
   while [ $n -lt ${#PKG_LIST[@]} ] ; do
      p="${PKG_LIST[$n]}"
      if test_pkg "$p" ; then
         rc=${PKG_RC[${n}]}
         if [ "$rc" = "0" ] ; then
            PKG_UPDATED_FILES=0
#            cd "${CPKG_INFO}/${p}"
            install_pkg_skel "$p" || true
            if [ ${PKG_UPDATED_FILES} -eq 0 ] ; then
               say_pkg_msg "$p" "(No update needed)"
               PKG_RC[${n}]=100
            else
               say_pkg_msg "$p" "[${PKG_UPDATED_FILES} file(s) updated]"
            fi
         else
            say_pkg_msg "$p" "*skipped* (preconfigure error)"
         fi
      fi
      n=$(($n + 1))
   done
   cd "${CURPWD}"
   say_msg "llxcfg-cpkg: END skel-installation"
   return 0
}

run_reset(){
   i=0
   while [ $i -lt ${#PKG_LIST[@]} ] ; do
      rc=1
      reset_pkg "${PKG_LIST[$i]}" || rc=0
      PKG_RC[${i}]=$rc
      i=$(($i + 1))
   done
   return 0
}

pkg_invoke(){
   local p rci
   p="$1"
   shift
   SRV_FILE="$(cpkg_dir "$p")/${CPKG_SERVICES_FILE}"
   if [ -s "$SRV_FILE" ] ; then
      SERVICES="$(cat "$SRV_FILE")"
      rci=0
      for srv in $SERVICES ; do
         if [ -x "/etc/init.d/${srv}" ] ; then
            invoke-rc.d "${srv}" "$@" || rci=$?
         fi
      done
      return $rci
   fi
   return 0
}

cpkg_init(){
   llxcfg-config dump "$CPKG_EXCLUDE_CONFDIR" > "$CPKG_EXCLUDE_LIST"
}

# ----
# main
# ----

# tests
[ -z "$1" ] && exit $CPKG_RC_BADPARAMETER
PIDFILE=""
VERBOSE=""
LOGFILE=""
while [ $# -ge 1 ] ; do
   case "$1" in
      --pidfile=*)
         PIDFILE="${1#--pidfile=}"
         shift
         ;;
      --verbose)
         VERBOSE="Y"
         shift
         ;;
      *)
         break
         ;;
   esac
done
[ "$PIDFILE" ] && echo "$$" > "$PIDFILE"
[ $(id -u) -ne 0 ] && exit $CPKG_RC_NOTROOT

SCRTOOL="/usr/sbin/llxcfg-script"
PKG_UPDATED_FILES=0
CPKG_ACTION="$1"
export CPKG_ACTION

shift
PKG_FILE=""
if [ "$CPKG_ACTION" = "post-dpkg" -o "$CPKG_ACTION" = "pre-dpkg" ] ; then
   if [ "$1" ] ; then
      PKG_FILE="$1"
      shift
   fi
fi
PKG_LIST0="$@"

case "$CPKG_ACTION" in
   pre-dpkg)
      # nothing to do on pre-dpkg
      exit 0
      ;;
   post-dpkg|update)
      get_pkg_list "$PKG_LIST0" || exit 0
      cpkg_init
      garbage_removal
      run_preconfig "set"
      install_skel "test"
      run_postconfig "test"
      ;;
   revert)
      get_pkg_list "$PKG_LIST0" || exit 0
      cpkg_init
      garbage_removal
      run_reset
      run_postconfig "test"
      ;;
   deconfigure)
      get_pkg_list "$PKG_LIST0" || exit 0
      cpkg_init
      garbage_removal
      run_reset
      ;;
   configure)
      get_pkg_list "$PKG_LIST0" || exit 0
      cpkg_init
      garbage_removal
      run_preconfig "set"
      install_skel "test"
      ;;
   postconfigure)
      get_pkg_list "$PKG_LIST0" || exit 0
      cpkg_init
      garbage_removal
      run_postconfig
      ;;
   allow)
      if [ -z "$1" ] ; then
         exit $CPKG_RC_BADPARAMETER
      fi
      get_pkg_list "$PKG_LIST0" || exit $?
      garbage_removal
      i=0
      while [ $i -lt ${#PKG_LIST[@]} ] ; do
         allow_pkg "${PKG_LIST[$i]}" || true
         i=$(($i + 1))
      done
      ;;
   deny)
      if [ -z "$1" ] ; then
         exit $CPKG_RC_BADPARAMETER
      fi
      get_pkg_list "$PKG_LIST0" || exit $?
      garbage_removal
      i=0
      while [ $i -lt ${#PKG_LIST[@]} ] ; do
         deny_pkg "${PKG_LIST[$i]}" || true
         i=$(($i + 1))
      done
      ;;
   enable)
      if [ -z "$1" ] ; then
         exit $CPKG_RC_BADPARAMETER
      fi
      cpkg_init
      garbage_removal
      enable_pkg "$1" "$2" || exit 0
      ;;
   disable)
      if [ -z "$1" ] ; then
         exit $CPKG_RC_BADPARAMETER
      fi
      cpkg_init
      garbage_removal
      disable_pkg "$1" "$2" || exit 0
      ;;
   invoke)
      if [ -z "$1" ] ; then
         exit $CPKG_RC_BADPARAMETER
      fi
      SRV_ACTION="$1"
      shift
      PKG_LIST0="$@"
      get_pkg_list "$PKG_LIST0" || exit 0
      i=0
      while [ $i -lt ${#PKG_LIST[@]} ] ; do
         p="${PKG_LIST[$i]}"
         pkg_invoke "$p" $SRV_ACTION || true
         i=$(( $i + 1 ))
      done
      ;;

   *)
      exit $CPKG_RC_BADPARAMETER
      ;;
esac

exit 0