#!/bin/sh
#
#  extbuild - a script to build extensions for Tiny Core Linux
#  .desc file idea derived from SvOlli (thanks!)
#  code (c) 2011 gutmensch
#  version 0.1
#  licensed under gplv3
#

# Root?
[ `id -u` -ne 0 ] &&  { echo "Must be root!"; exit 1; }
[ -z "$1" -o ! -e "$1" ] &&  { echo "Usage: sudo ../extbuild extension.tcz.bld"; exit 1; }

# Source tc-functions and colors
. "/etc/init.d/tc-functions"

#####################################################################
############## Modify .desc file before sourcing it #################
#####################################################################
STDIFS=" 
	"
IFS=$'\n'
DESCFILE="`realpath $1`"

DATE=`date +%Y/%m/%d`
CHANGE=`cat $DESCFILE | grep "CHANGE=\"" | sed 's?CHANGE=\"\(.*\)\"?\1?'`

# if change has no entry then dismiss
if [ "$CHANGE" = "__TODAY__ " ]; then
  echo -e -n "${YELLOW}Warning: No new changelog entry made.${NORMAL}\n${WHITE}Continue, overwrite with new date or abort? [c/o/a]: "
  read junk
  echo "${NORMAL}"
  # Abort
  [ "$junk" = "a" ] && echo "Aborting." && exit 1
  # Overwrite
  if [ "$junk" = "o" ]; then
    # Setting date of last changelog entry to current date
    lastline="`grep CHANGELOG $DESCFILE | head -n 1 | cut -d'=' -f2`"
    lastdate=`echo "$lastline" | sed 's:"\([0-9]*/[0-9]*/[0-9]*\) .*:\1:' 2>/dev/null`
    if [ "$DATE" != "$lastdate" ]; then
      newline=`echo $lastline | sed "s:$lastdate:$DATE:" 2>/dev/null`
      sed -i -e "s:$lastline:$newline:" $DESCFILE 2>/dev/null
    fi
  fi
else
  # maybe new package and empty changelog?
  if [ -z "`cat $DESCFILE | grep CHANGELOG | head -n 1`" ];then
    endofchangelog="`cat $DESCFILE | grep '############### end of changelog'`"
    indexnext=0
    CHANGE=`echo $CHANGE | sed "s?__TODAY__?$DATE?" 2>/dev/null`
    nextentry="#CHANGELOG[$indexnext]=\"$CHANGE\""
    sed -i "s?############### end of changelog.*?$nextentry\n$endofchangelog?" $DESCFILE 2>/dev/null
  else
    # get latest changelog entry
    for i in `cat $DESCFILE | grep CHANGELOG | head -n 1`
    do
      lastentry="`echo $i | sed 's?#CHANGELOG.*=\"\(.*\)\"?\1?' 2>/dev/null`"
      indexlast="`echo $i | sed 's?#CHANGELOG\[\(.*\)\].*?\1?' 2>/dev/null`"
      indexnext=$(( $indexlast + 1 ))
      # modify date string to version appendix if same date of last change
      datestring="`echo $lastentry | cut -d' ' -f1`"
      if [ "$datestring" = "$DATE" ];then
        DATE="$DATE-1"
      else
        datestring2="`echo $datestring | cut -d'-' -f1`"
        if [ "$datestring2" = "$DATE" ];then
          dateversion="`echo $datestring | cut -d'-' -f2`"
          newdateversion=$(( $dateversion + 1 ))
          DATE="$DATE-$newdateversion"
        fi
      fi
      CHANGE=`echo $CHANGE | sed "s?__TODAY__?$DATE?"`
      nextentry="#CHANGELOG[$indexnext]=\"$CHANGE\""
      sed -i "s?#CHANGELOG.$indexlast.=.*?$nextentry\n$i?" "$DESCFILE" 2>/dev/null
    done
  fi
  # reset CHANGE var
  sed -i "s?CHANGE=\".*\"?CHANGE=\"__TODAY__ \"?" "$DESCFILE" 2>/dev/null
fi

# Reset IFS
IFS=$STDIFS

#####################################################################
#####################################################################
#####################################################################

##################################### VARS #############################################
# Static compiler flags
export LANG="C"
export LANGUAGE="C"
export LC_ALL="C"
export CFLAGS="-march=i486 -mtune=i686 -Os -pipe -fomit-frame-pointer"
export CXXFLAGS="-march=i486 -mtune=i686 -Os -pipe -fno-exceptions -fno-rtti"
export CPPFLAGS="-I/usr/local/include -I/usr/include"
export LDFLAGS="-L/usr/local/lib -L/usr/lib -L/lib -Wl,-O1 -Wl,--hash-style=gnu"
export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig:/usr/lib/pkgconfig
BASE_FLAGS="--enable-static --enable-shared --prefix=/usr/local --localstatedir=/var --sysconfdir=/usr/local/etc --mandir=/usr/local/share/man"
BASE_BUILD_DEPS="compiletc squashfs-tools-4.x ntpclient sstrip upx gzip lsof xz zsync findutils file"
UPX_OPTS="--best --ultra-brute -f"
COMPRESSOR="xz -z -f -9 -e"
let BUILD_THREADS="`cat /proc/cpuinfo | grep -e 'processor[[:space:]]*:' | wc -l`+1"
CONFIGURE_CMD="./configure"
MAKE_CMD="make -j$BUILD_THREADS"
MAKE_TEST_CMD="make test ; make check"
MAKE_INSTALL_CMD="make install" 
AFTER_INSTALL_CMD=""
AFTER_CONFIGURE_CMD=""
RELEASE=`uname -r`

# Misc static vars
TCB_SRCDIR="`pwd`/src"
TCB_BLDDIR="`pwd`/build"
TODAY="`date +%Y/%m/%d`"
TCUSER=`cat /etc/sysconfig/tcuser`
TCEMIRROR="http://distro.ibiblio.org/pub/linux/distributions/tinycorelinux/3.x/tcz/"
DUMMY_FILES=""

# Getting extension info
. "$DESCFILE"

# Correcting place of logfile if RENAME_TO used
LOGFILE="${TCB_BLDDIR}/../build.log"

#################################### END OF VARS ######################################

### FUNCTIONS
log() {
  if [ -n "$1" ] && [ -n "$2" ];then
    tstamp=`date +"%d.%m.%y %T"`
    # $1 = Level: 0 Info, 1 Warning, 2 Error
    # $2 = Text
    case $1 in 
      0) ERRORMSG="[$tstamp] Info   : $2" ;;
      1) ERRORMSG="[$tstamp] Warning: $2" ;;
      2) ERRORMSG="[$tstamp] *ERROR*: $2" ;;
      *) return ;;
    esac
    echo "${ERRORMSG}" >> ${LOGFILE}
    [ $1 -eq 2 ] && fail
  fi
}

init_logfile() {
  # creating log file and dumping all config info 
  mkdir -p `dirname ${LOGFILE}` 2>/dev/null
  touch $LOGFILE || export LOGFILE=/dev/null
  chown ${TCUSER}:staff $LOGFILE
  log 0 " ====== Welcome to tcbuild :-) ====== "
  log 0 "Printing environment:"
  printenv >> $LOGFILE
  log 0 "Dumping variables:"
  for var in DESCFILE DATE CHANGE LANG LANGUAGE LC_ALL RELEASE \
             CFLAGS CXXFLAGS CPPFLAGS ACLOCAL_AMFLAGS LDFLAGS \
             PKG_CONFIG_PATH BASE_FLAGS BASE_BUILD_DEPS COMPRESSOR \
             CONFIGURE_CMD MAKE_CMD MAKE_TEST_CMD MAKE_INSTALL_CMD \
             AFTER_CONFIGURE_CMD AFTER_INSTALL_CMD BUILD_THREADS \
             TCB_SRCDIR TCB_BLDDIR TODAY TCUSER TCEMIRROR \
             STYPE MIRROR PACKAGE SEP VERSION PKG_EXT RENAME_TO \
             BUILD_DEPS RUN_DEPS TCE_REPO FLAGS OVERWRITE_LOCAL \
             DEV_MASK CONF_MASK CONF_MAND_MASK LOCALE_MASK DOC_MASK \
             NO_PERL NO_OWN_MOD NO_AUTOTOOLS NO_DESTDIR DBG_PKG UPX_COMPRESS UPX_OPTS \
             DESCRIPTION AUTHORS MAINTAINER HOMEPAGE LICENSE COMMENTS
  do
    value="$(eval echo \${$var})"
    log 0 "$var: $value"
  done
}

online() {
  ping www.google.de -c 1 1>/dev/null 2>&1
  echo $?
}

update_files() {
  if [ -n "$1" ];then
    chown -R root:staff "$1" 
    find "$1" -type f -exec touch {} +
  fi
}

success() {
  echo "${GREEN}success.${NORMAL}"
}

fail() {
  echo "${RED}failed."
  echo "Last ten lines of log show:"
  cat $LOGFILE | tail -n 10
  echo "${NORMAL}"
  exit 1
}

check_perl() {
  # searching for perl files in ext directory
  FOUND=1
  log 0 "Searching for perl dependencies... "
  find "${TCB_BLDDIR}/$1" -type f -exec file {} \; | grep perl | cut -d: -f1 | xargs sed -i -e '1s"^#!.\+$"#!/usr/local/bin/perl -w"' 1>>$LOGFILE 2>&1 && FOUND=0
  find "${TCB_BLDDIR}/$1" -type f -exec file {} \; | grep perl 1>>$LOGFILE 2>&1
  echo $FOUND
}
 
strip_compress_files() {
  if [ -z "${DBG_PKG}" ]; then
    # no dbg extension, just strip everything
    for elf in `find ${TCB_BLDDIR} -exec file {} \; | grep -e "ELF.*shared object\|ELF.*executable" | cut -d: -f1`; do
      origsize=`du -h $elf | awk '{print $1}'`
      strip --strip-unneeded --strip-debug $elf 1>>$LOGFILE 2>&1 
      newsize=`du -h $elf | awk '{print $1}'`
      log 0 "Stripping file $elf... reduced from $origsize to $newsize."
      if [ -n "`file $elf | grep executable`" ]; then
        origsize=`du -h $elf | awk '{print $1}'`
        sstrip $elf 1>> $LOGFILE 2>&1
        newsize=`du -h $elf | awk '{print $1}'`
        log 0 "S-stripping executable $elf... reduced from $origsize to $newsize."
      fi
    done
  else
    # create debug extension
    for elf in `find ${TCB_BLDDIR} -exec file {} \; | grep -e "ELF.*shared object\|ELF.*executable" | cut -d: -f1`; do
      origsize=`du -h $elf | awk '{print $1}'`
      objcopy --only-keep-debug $elf $elf.dbg
      objcopy --strip-debug --strip-unneeded $elf
      objcopy --add-gnu-debuglink=$elf.dbg $elf
      newsize1=`du -h $elf | awk '{print $1}'`
      newsize2=`du -h $elf.dbg | awk '{print $1}'`
      log 0 "Stripped debug info from $elf ($origsize) into `basename $elf` ($newsize1) and `basename $elf.dbg` ($newsize2)."
    done
  fi
  if [ -n "${UPX_COMPRESS}" ]; then
    # requested to compress executables with upx
    echo "${RED}Warning: Using UPX to compress files.${NORMAL}"
    for elf in `find ${TCB_BLDDIR} -exec file {} \; | grep -e "ELF.*executable" | cut -d: -f1`; do
      origsize=`du -h $elf | awk '{print $1}'`
      upx ${UPX_OPTS} $elf 1>>$LOGFILE 2>&1
      newsize=`du -h $elf | awk '{print $1}'`
      log 0 "Upx'ing `basename $elf`... reduced from $origsize to $newsize."
    done
  fi
}

dummy_file() {
  # create temporary executable dummy file needed by some builds
  # def. goes to /usr/local/bin/
  # $1 should be the name
  # $2 can be optional cmd list for content of dummy file
  if [ -n "$1" ];then
    for file in $@
    do
      if [ ! -e /usr/local/bin/$file ];then
        log 0 "Creating dummy file /usr/local/bin/$file."
        touch /usr/local/bin/$file
        echo -e "#!/bin/sh\n" >> /usr/local/bin/$file
        [ -n "$2" ] && echo -e "$2\n" >> /usr/local/bin/$file
        echo -e "exit 0\n" >> /usr/local/bin/$file
        chmod +x /usr/local/bin/$file
        DUMMY_FILES="${DUMMY_FILES} /usr/local/bin/$file"
      fi
    done
  fi
}

tmp_install() {
  touch /tmp/tmp_install_mark
  ${MAKE_INSTALL_CMD} 1>>$LOGFILE 2>&1
  retval=$?
  find $1 -newer /tmp/tmp_install_mark -not -type d > /tmp/tmp_install_list
  [ ! -s /tmp/tmp_install_list ] && echo -e "\n" && log 2 "tmp_install_list from $1 is empty, no files found, maybe wrong prefix installation?!"
  tar -T /tmp/tmp_install_list -czf ${TCB_BLDDIR}/${PACKAGE}_installed.tgz 1>>$LOGFILE 2>&1
  find /usr/local -newer /tmp/tmp_install_mark -not -type d -exec rm -rvf {} 1>>$LOGFILE 2>&1 \;
  tar -xzf ${TCB_BLDDIR}/${PACKAGE}_installed.tgz -C ${TCB_BLDDIR}/${PACKAGE}/ 1>>$LOGFILE 2>&1
  rm -f /tmp/tmp_install_list
  rm -f /tmp/tmp_install_mark
  rm -f ${TCB_BLDDIR}/${PACKAGE}_installed.tgz
  return $retval
}

fn_exists() {
  type $1 | grep -q 'shell function'
  echo $?
}

install_license() {
  if [ -d "${TCB_BLDDIR}/$1" ];then
    EMPTY="`find ${TCB_BLDDIR}/$1 -type f`"
    if [ ! -z "${EMPTY}" ];then
      # pkg should be $1
      licdir="${TCB_BLDDIR}/${1}/usr/local/share/doc/License"
      mkdir -p "${licdir}" || exit 1
      # copying license, patents or authors files
      # CREDITS THANKS CHANGELOG COMPATIBILITY README VERSION
      for i in LICENSE COPYING COPYRIGHT AUTHORS PATENTS ; do
        doctype="-$(echo $i | tr '[:upper:]' '[:lower:]')"
        [ "$doctype" = "-license" ] && doctype=""
        [ -e "${TCB_SOURCE}/$i" ] && cp "${TCB_SOURCE}/$i" "${licdir}/${1}${doctype}.txt" && log 0 "Installed ${licdir}/${1}${doctype}.txt."
        [ -e "${TCB_SOURCE}/$i.txt" ] && cp "${TCB_SOURCE}/$i.txt" "${licdir}/${1}${doctype}.txt" && log 0 "Installed ${licdir}/${1}${doctype}.txt."
      done
    fi
  fi
}

to_new_extension() {
  EMPTY=0
  CURRDIR=$(pwd)
  cd ${TCB_BLDDIR}/${PACKAGE}
  # $1 should be find regex, for example "-name bla.conf -o -name blu.txt"
  # $2 should be name of new package
  # $3 should be list of deps
  #
  # unloading if loaded
  [ -d /tmp/tcloop/$2 ] && tceunload $2
  # generating
  if [ -n "$1" ] && [ -n "$2" ];then
    for I in $(find `ls` $1 ); do        
      [ ! -e "${TCB_BLDDIR}/$2" ] && mkdir -p "${TCB_BLDDIR}/$2"
      export DIR=`dirname "$I"`
      [ -d "${TCB_BLDDIR}/$2/${DIR}" ] || mkdir -p "${TCB_BLDDIR}/$2/${DIR}"
      mv "$I" "${TCB_BLDDIR}/$2/${DIR}/" 2>/dev/null
      EMPTY=1
    done
    if [ $EMPTY -eq 1 ];then
      # generate dep file
      for dep in $3
      do
        echo -n -e "$dep.tcz\n" | sed "s:${RELEASE}:KERNEL:" >> ${TCB_BLDDIR}/$2.tcz.dep
      done
    fi
  fi
  cd ${TCB_BLDDIR}
  # license only in main extension
  #install_license $2
  # remove empty dirs
  remove_empty_dirs "${TCB_BLDDIR}"
  cd ${CURRDIR}
}

tceunload() {
  # need file list to remove files from system
  if [ ! -e "${TCE_REPO}/optional/$1.tcz.list" ];then
    # try downloading
    echo "Downloading $TCEMIRROR/$1.tcz.list... " >> $LOGFILE
    wget "$TCEMIRROR/$1.tcz.list" -O "${TCE_REPO}/optional/$1.tcz.list" 1>/dev/null 2>>$LOGFILE
    if [ $? -eq 0 ];then
      chown tc:staff "${TCE_REPO}/optional/$1.tcz.list"
    else
      return;
    fi
  fi
  # Search for open files
  for openfile in `lsof | grep /tmp/tcloop/$1/`
  do
    pname=`echo $openfile | awk '{print $1}'`
    ppid=`echo $openfile | awk '{print $2}'`
    puser=`echo $openfile | awk '{print $3}'`
    pfile=`echo $openfile | awk '{print $9}'`
    log 1 "Found open file $pfile by process $pname (PID $ppid) from user $puser! Umount of extension maybe not possible."
    [ "$$" != "$ppid" ] && { 
      log 0 "Killing $ppid." ;
      kill $ppid 2>>$LOGFILE ;
    }
  done
  # Umounting and erasing
  umount -f /tmp/tcloop/$1 || log 1 "Could not umount tcz $1."
  loopdev=`losetup | grep $1.tcz | cut -d: -f1`
  losetup -d $loopdev 1>>$LOGFILE 2>&1 && \
  	rmdir /tmp/tcloop/$1 1>>$LOGFILE 2>&1 || \
  	log 1 "Could not detach loop device $loopdev!"
  [ -e "/usr/local/tce.installed/$1" ] && rm /usr/local/tce.installed/$1
  for file in `cat ${TCE_REPO}/optional/$1.tcz.list`; do
    [ -z `echo $file | grep init.d` ] || {
      log 0 "Trying to stop /$file..." ;
      sh /$file stop 1>>$LOGFILE 2>&1 ;
      sleep 2 ;
    }
    if [ -e "/$file" ] || [ -L "/$file" ];then
      log 0 "Removing /$file"
      rm -rf "/$file"
    fi
  done
}

generate_changelog () {
  # $1 must be desc file
  IFS=$'\n'
  tmpfile1=`mktemp`
  for i in `cat $1 | grep CHANGELOG | sed '/^\s*$/d'`
  do
    index=`echo $i | cut -d'[' -f2 | cut -d']' -f1` 
    index5=`printf "%.5d" "$index"` 
    entry=`echo $i | sed "s?#CHANGELOG\[.*\]?#CHANGELOG[${index5}]?"` 
    echo "$entry" >> $tmpfile1
  done 
  for i in `cat $tmpfile1 | sort | sed '$d'`
  do
    entry="`echo $i | sed 's?#CHANGELOG.*=\"\(.*\)\"?\1?' | sed 's? ?	?'`"
    if [ -z "$CHANGELOG" ];then
      CHANGELOG="$entry"
    else
      CHANGELOG="$CHANGELOG
		$entry"
    fi
  done
  CURRENT="`cat $tmpfile1 | sort | tail -n 1 | sed 's?#CHANGELOG.*=\"\(.*\)\"?\1?' | sed 's? ?	?'`"
  IFS=$STDIFS
  rm $tmpfile1
}

init_build () {
	# Initializing logfile
	init_logfile
	# get tce repo
	[ -z "${TCE_REPO}" ] && export TCE_REPO="`cat /opt/.tce_dir`"
	# Creating dirs
	busybox mkdir -p "${TCB_SRCDIR}"
	[ -d "${TCB_BLDDIR}" ] && busybox rm -rf "${TCB_BLDDIR}"
	busybox mkdir -p "${TCB_BLDDIR}/src"
	# Add debugging to build if DBG_PKG is set
	if [ -n "$DBG_PKG" ]; then
	  # Remove omit frame pointer when debugging because it can lead to errors
	  export CFLAGS="`echo ${CFLAGS} | sed 's/-fomit-frame-pointer//'` -g3 -DDEBUG" 
	  log 0 "Changed CFLAGS to ${CFLAGS}."
	  export CXXFLAGS="${CXXFLAGS} -g3 -DDEBUG"
	  log 0 "Changed CXXFLAGS to ${CXXFLAGS}."
	  BASE_FLAGS="${BASE_FLAGS} --enable-debug"
	  log 0 "Changed BASE_FLAGS to ${BASE_FLAGS}."
	fi	
	# Remove old versions from tce repo and unload if loaded
	[ -n "${OVERWRITE_LOCAL}" ] && [ -d /tmp/tcloop/${PACKAGE} ] && tceunload ${PACKAGE}
	[ -n "${OVERWRITE_LOCAL}" ] && rm -f ${TCE_REPO}/optional/${PACKAGE}*.tcz*
	# Set date if possible
	if [ -e "/usr/local/bin/ntpclient" ] && [ $(online) -eq 0 ]; then
	  log 0 "Adjusting time."
	  ntpclient -s -c 1 -h 0.de.pool.ntp.org 1>>$LOGFILE 2>&1
	else
	  log 1 "Could not update time!"
	fi
	# Getting build deps
	if [ $(online) -eq 0 ];then
	  for bbdep in ${BASE_BUILD_DEPS} ; do
	    log 0 "Got $bbdep as base building dependency."
	    if [ ! -d "/tmp/tcloop/$bbdep" ];then
  	      log 0 "Installing base build dep: $bbdep..."
	      su -c "tce-load -wi $bbdep 1>/dev/null 2>&1" ${TCUSER}
	      su -c "tce-load -i $bbdep 1>>$LOGFILE 2>&1" ${TCUSER}
	      su -c "tce-load -i ${TCE_REPO}/optional/$bbdep.tcz 1>/dev/null 2>&1" ${TCUSER}
	    else
	      log 1 "Directory '/tmp/tcloop/$bbdep' already exists. Won't install."
	    fi
	  done
	  for bdep in ${BUILD_DEPS} ; do
	    log 0 "Got $bdep as building dependency."
	    if [ ! -d "/tmp/tcloop/$bdep" ];then
	      log 0 "Installing build dep: $bdep..."
	      su -c "tce-load -wi $bdep 1>>$LOGFILE 2>&1" ${TCUSER}
	      su -c "tce-load -i $bdep 1>>$LOGFILE 2>&1" ${TCUSER}
	      su -c "tce-load -i ${TCE_REPO}/optional/$bdep.tcz 1>>$LOGFILE 2>&1" ${TCUSER}
	    else
	      log 1 "Directory '/tmp/tcloop/$bdep' already exists. Won't install."
	    fi
	    # trying to install dev package for extension
	    if [ -z "`echo $bdep | grep "\-dev"`" ]; then
	      if [ ! -d "/tmp/tcloop/$bdep-dev" ];then
	        log 0 "Installing build dep development extension: $bdep-dev..."
	        su -c "tce-load -wi $bdep-dev 1>>$LOGFILE 2>&1" ${TCUSER}
	        su -c "tce-load -i $bdep-dev 1>>$LOGFILE 2>&1" ${TCUSER}
	        su -c "tce-load -i ${TCE_REPO}/optional/$bdep-dev.tcz 1>>$LOGFILE 2>&1" ${TCUSER}
	      else
	        log 1 "Directory '/tmp/tcloop/$bdep-dev' already exists. Won't install."
	      fi
	    fi
	  done
	  # download list files from extensions
	  download_lists
	else
	  log 1 "No Internet connection available."
	fi
	# generating changelog from desc file
	generate_changelog "$1"
	# copy desc file to src folder
	if [ -z "${RENAME_TO}" ]; then
	  mkdir -p "${TCB_BLDDIR}/src/${PACKAGE}"
	  cp "$1" "${TCB_BLDDIR}/src/${PACKAGE}/${PACKAGE}.desc"
	else
	  mkdir -p "${TCB_BLDDIR}/src/${RENAME_TO}"
	  cp "$1" "${TCB_BLDDIR}/src/${RENAME_TO}/${RENAME_TO}.desc"
	fi
}

get_source () {
  # Erasing old source folder
  [ -d "${TCB_SRCDIR}/${PACKAGE}${SEP}${VERSION}" ] && rm -rf "${TCB_SRCDIR}/${PACKAGE}${SEP}${VERSION}" 2>/dev/null
  [ -d "${TCB_SRCDIR}/${RENAME_TO}${SEP}${VERSION}" ] && rm -rf "${TCB_SRCDIR}/${RENAME_TO}${SEP}${VERSION}" 2>/dev/null
  if [ ! -e "${TCB_SRCDIR}/${PACKAGE}${SEP}${VERSION}${PKG_EXT}" ];then
    case ${STYPE} in
      git) get_source_git ;;
      svn) get_source_svn ;;
      *) get_source_http ;;
    esac
  fi
  # Unpacking source
  if [ "${PKG_EXT}" = ".zip" ];then
    cd ${TCB_SRCDIR}
    unzip ${PACKAGE}${SEP}${VERSION}${PKG_EXT} 2>>$LOGFILE || log 2 "Failed to unzip."
    cd -
  else
    tar xf ${TCB_SRCDIR}/${PACKAGE}${SEP}${VERSION}${PKG_EXT} -C ${TCB_SRCDIR} 2>>$LOGFILE || log 2 "Failed to untar."
  fi
  update_files "${TCB_SRCDIR}"
  # Renaming folder if RENAME_TO set
  if [ -n "$RENAME_TO" ];then
    mv "${TCB_SRCDIR}/${PACKAGE}${SEP}${VERSION}" "${TCB_SRCDIR}/${RENAME_TO}${SEP}${VERSION}"
    export ORIG_NAME="${PACKAGE}"
    export PACKAGE="${RENAME_TO}"
  fi
  # Exporting variable TCB_SOURCE
  export TCB_SOURCE="${TCB_SRCDIR}/${PACKAGE}${SEP}${VERSION}"
}

get_source_http () {
  if [ $(online) -eq 0 ]; then
    log 0 "Downloading ${STYPE}://${MIRROR}/${PACKAGE}${SEP}${VERSION}${PKG_EXT}" ;
    wget --no-check-certificate -q "${STYPE}://${MIRROR}/${PACKAGE}${SEP}${VERSION}${PKG_EXT}" -O ${TCB_SRCDIR}/${PACKAGE}${SEP}${VERSION}${PKG_EXT} ;
    if [ $? -ne 0 ];then
      log 1 "Could not receive file, will try again with -src suffix." ;
      wget --no-check-certificate -q "${STYPE}://${MIRROR}/${PACKAGE}${SEP}${VERSION}-src${PKG_EXT}" -O ${TCB_SRCDIR}/${PACKAGE}${SEP}${VERSION}${PKG_EXT} || log 2 "Failed to download." ;
    fi
  else
    log 1 "No network connectivity?!"
  fi
}

get_source_git () {
  if [ ! -e /usr/local/tce.installed/git-2.6 ];then
    if [ $(online) -eq 0 ];then
      su -c "tce-load -wi git-2.6.tcz 1>/dev/null 2>&1" ${TCUSER}
      su -c "tce-load -i git-2.6.tcz 1>/dev/null 2>&1" ${TCUSER}
      echo "git:" >> ${ABLDEXTS}
    else
      log 2 "Could not download git."
    fi
  fi
  CURRDIR=`pwd`
  cd ${TCB_SRCDIR}
  ### downloading ###
  GITCMD=`which git`
  log 0 "Running ${GITCMD} clone ${STYPE}://${MIRROR}/${PACKAGE}.git ... "
  ${GITCMD} clone ${STYPE}://${MIRROR}/${PACKAGE}.git 1>>$LOGFILE 2>&1 || log 2 "Could not checkout git version."
  cd ${PACKAGE}
  git describe 1>/dev/null 2>&1
  if [ $? -eq 0 ];then
    export VERSION=`git describe | sed 's/^v//'`
  else
    export VERSION=git`git log --pretty=oneline | wc -l`
  fi
  export PKG_EXT=".tar.gz"
  cd ..
  mv ${PACKAGE} ${PACKAGE}${SEP}${VERSION}
  tar czf ${PACKAGE}${SEP}${VERSION}.tar.gz ${PACKAGE}${SEP}${VERSION}
  sed -i -e "s%VERSION=\".*\"%VERSION=\"${VERSION}\"%" $DESCFILE
  sed -i -e "s%PKG_EXT=\".*\"%PKG_EXT=\".tar.gz\"%" $DESCFILE
  rm -rf ${PACKAGE}${SEP}${VERSION}
  cd ${CURRDIR}
}

get_source_svn () {
  if [ ! -e /usr/local/tce.installed/svn ];then
    if [ $(online) -eq 0 ];then
      su -c "tce-load -wi svn.tcz 1>/dev/null 2>&1" ${TCUSER}
      su -c "tce-load -i svn.tcz 1>/dev/null 2>&1" ${TCUSER}
      echo "svn:" >> ${ABLDEXTS}
    else
      log 2 "Could not download svn."
    fi
  fi
  CURRDIR=`pwd`
  cd ${TCB_SRCDIR}
  ### downloading ###
  SVNCMD=`which svn` 
  ${SVNCMD} checkout ${MIRROR} ${PACKAGE} 1>>$LOGFILE 2>&1 || log 2 "Could not checkout svn version."
  cd ${PACKAGE}
  SVNVERS=`svn info | grep Revision | cut -d' ' -f2`
  export VERSION="svn${SVNVERS}"
  export PKG_EXT=".tar.gz"
  cd ..
  mv ${PACKAGE} ${PACKAGE}${SEP}${VERSION}
  tar czf ${PACKAGE}${SEP}${VERSION}.tar.gz ${PACKAGE}${SEP}${VERSION}
  sed -i -e "s%VERSION=\".*\"%VERSION=\"${VERSION}\"%" $DESCFILE
  sed -i -e "s%PKG_EXT=\".*\"%PKG_EXT=\".tar.gz\"%" $DESCFILE
  rm -rf ${PACKAGE}${SEP}${VERSION}
  cd ${CURRDIR}
}

download_lists () {
  for extension in `ls ${TCE_REPO}/optional/*.tcz`
  do
    if [ ! -f "$extension.list" ] || [ ! -s "$extension.list" ]; then
      # KERNEL variable?
      extension=`echo $extension | sed "s:KERNEL:${RELEASE}:"`
      su -c "wget -q ${TCEMIRROR}/`basename $extension`.list -O $extension.list" ${TCUSER} && {
        log 0 "Downloaded $extension.list." ; } || {
        log 1 "Could not download `basename $extension`.list." ; }
    fi
  done
}

check_run_deps () {
  [ ! -d "${TCB_BLDDIR}/$1" ] && return
  CURRDIR=`pwd`
  cd ${TCB_BLDDIR}
  log 0 "Recursively checking deps of modules and binaries for package $1."
  templist=`mktemp`
  for item in `find $1 -name "*.so" -o -wholename "*bin/*" | tr '\n' ' '`
  do
    log 0 "  + Checking deps of file `basename $item`."
    ldd $item 2>/dev/null | grep "local\|not found" 1>/dev/null 2>&1
    if [ $? -ne 0 ];then
      log 0 "    - No additional deps needed for $item."
    else
      for moddep in `ldd $item 2>/dev/null | grep "local\|not found" | awk '{print \$1}' | tr '\n' ' '`
      do
        log 0 "    + Found module dep: $moddep." 
        MISSINGLIB=1
        # dep must be in build folder itself or...
        tempval=`find ${TCB_BLDDIR} -name $moddep`
        [ ! -z "$tempval" ] && {
          tempname=`basename $(find ${TCB_BLDDIR} -name $moddep | sed 's:\(.*\)/usr/local/.*:\1:')` ;
          MISSINGLIB=0 ;
          log 0 "      => satisfied by : *** $tempname.tcz *** " ;
        }
        # ..in any list file of TCE_REPO
        if [ ${MISSINGLIB} -eq 1 ];then
          for listfile in `ls ${TCB_BLDDIR}/*.list ${TCE_REPO}/optional/*.list 2>/dev/null`
          do
            grep -e "/$moddep\$" $listfile 1>/dev/null 2>&1 && {
              log 0 "      => satisfied by : *** `basename $listfile | sed 's/\.list//'` *** " ;
              echo $listfile | sed 's/\.list//' >> $templist ;
              MISSINGLIB=0 ;
              break ;
            }
          done
        fi
        # ...still missing, dep not found!
        if [ ${MISSINGLIB} -eq 1 ];then
          log 1 "      CRITICAL: Dependency ${moddep} not found!"
        fi
      done
    fi
  done
  # sort dep file, deps with most own deps first
  cat $templist | sort | uniq | sed 's:.*/\(.*\):\1:g' > ${TCB_BLDDIR}/src/${PACKAGE}/${1}.tcz.dep-auto
  rm -f $templist
  if [ ! -e ${TCB_BLDDIR}/${1}.tcz.dep ];then
    echo "${YELLOW} * Warning: No $1.tcz.dep file found!${NORMAL}"
  fi
  for extensionfile in `cat ${TCB_BLDDIR}/src/${PACKAGE}/${1}.tcz.dep-auto | tr '\n' ' '` ; do
    grep $extensionfile ${TCB_BLDDIR}/$1.tcz.dep 1>/dev/null 2>&1
    [ $? -ne 0 ] && echo "${YELLOW} * Warning: ${WHITE}$1.tcz${YELLOW} probably needs ${RED}$extensionfile${YELLOW} as dep!${NORMAL}"
  done
  cd ${CURRDIR}
}

configure_source () {
  # Starting configuration
  [ -n "${TCB_SOURCE}" ] && update_files "${TCB_SOURCE}" && cd "${TCB_SOURCE}" || log 2 "Could not cd to source dir!"
  if [ -n "${BOOTSTRAP}" ]; then
    [ -e "./bootstrap" ] && ./bootstrap 1>>$LOGFILE 2>&1
  fi
  if [ -z "${NO_AUTOTOOLS}" ];then
    [ -e "./autogen.sh" ] && ./autogen.sh 1>>$LOGFILE 2>&1
    [ -e "./configure.ac" ] && [ -e "/usr/local/bin/autoreconf" ] && autoreconf -vfi 1>>$LOGFILE 2>&1
    [ -e "./acconfig.h" ] && [ -e "/usr/local/bin/autoreconf" ] && autoreconf -vfi 1>>$LOGFILE 2>&1
    [ -e "/usr/local/bin/autoscan" ] && autoscan 1>>$LOGFILE 2>&1
  fi
  if [ -e "${CONFIGURE_CMD}" ];then
    echo "+++++++++++++++++++++++++++ ./configure --help ++++++++++++++++++++++++++++++++" >> $LOGFILE
    ${CONFIGURE_CMD} --help 1>>${LOGFILE} 2>&1
    echo "++++++++++++++++++++++++++ end of configure help +++++++++++++++++++++++++++++++" >> $LOGFILE
    trap 'cat ${LOGFILE} && exit 0' SIGINT
    echo "${WHITE}------------------------------------------------------------------------"
    echo -n -e " Configure help and build log can be found in:\n\t\t ${MAGENTA}`realpath ${LOGFILE}`${WHITE}.\n"
    echo " Press Ctrl + C to quit and show it now."
    echo " Waiting 10 seconds... "
    echo "------------------------------------------------------------------------${NORMAL}"
    sleep 10
    trap - SIGINT
    echo -n -e "${YELLOW} * Configuring source... \t\t\t\t\t${NORMAL}"
    ${CONFIGURE_CMD} ${BASE_FLAGS} ${FLAGS} 1>>$LOGFILE 2>&1 && success || fail
  else
    if [ -n "${CONFIGURE_CMD}" ];then
      log 0 "Executing special configure command: ${CONFIGURE_CMD} in `pwd`."
      echo -n -e "${YELLOW} * Configuring source... \t\t\t\t\t${NORMAL}"
      eval "${CONFIGURE_CMD} ${BASE_FLAGS} ${FLAGS}" 1>>$LOGFILE 2>&1 && success || fail
    else
      echo
      echo ${RED}WARNING: No configure script found!${NORMAL}
    fi
  fi
  if [ -e "config.log" ];then
    log 0 "Checking for not found files from config.log:"
    grep "No such file" config.log 1>>$LOGFILE 2>&1
  fi
  if [ -n "${AFTER_CONFIGURE_CMD}" ];then
    eval "${AFTER_CONFIGURE_CMD}"
  fi
}

make_build () {
        [ -n "${TCB_SOURCE}" ] && cd "${TCB_SOURCE}" || log 2 "Could not cd to source dir!"
	# Building
	echo -n -e "${YELLOW} * Making... \t\t\t\t\t\t\t${NORMAL}"
	if [ -n "${MAKE_CMD}" ];then
	  log 0 "Executing make command ${MAKE_CMD}... "
          eval "${MAKE_CMD}" 1>>$LOGFILE 2>&1 && success || fail
	else
	  log 2 "No MAKE_CMD given."
	fi
	if [ -n "${MAKE_TEST_CMD}" ];then
	  log 0 "Executing test."
	  eval "${MAKE_TEST_CMD}" 1>>$LOGFILE 2>&1
	else
	  log 0 "No MAKE_TEST_CMD given."
	fi
	# Installing
	echo -n -e "${YELLOW} * Installing... \t\t\t\t\t\t${NORMAL}"
	mkdir -p ${TCB_BLDDIR}/${PACKAGE}
	if [ -n "${NO_DESTDIR}" ];then
	  tmp_install /usr/local && success || fail
	else
	  export INSTALL_ROOT="${TCB_BLDDIR}/${PACKAGE}"
	  export DESTDIR="${TCB_BLDDIR}/${PACKAGE}"
	  eval "${MAKE_INSTALL_CMD}" 1>>$LOGFILE 2>&1 && success || fail
	  [ -n "${AFTER_INSTALL_CMD}" ] && eval ${AFTER_INSTALL_CMD} 1>>$LOGFILE 2>&1
	fi
}

create_start_script () {
  # $1 should be package name, if empty then use ${PACKAGE}
  [ -z "$1" ] && PKG=${PACKAGE} || PKG=$1
  [ ! -d "${TCB_BLDDIR}/${PKG}" ] && log 2 "Did not find extension folder for specified start script."
  # Create start script and put to first free var from SS1 to SS4
  if [ ! -e "${TCB_BLDDIR}/${PKG}/usr/local/tce.installed/${PKG}" ];then
    mkdir -p ${TCB_BLDDIR}/${PKG}/usr/local/tce.installed
    touch ${TCB_BLDDIR}/${PKG}/usr/local/tce.installed/${PKG}
    chmod -R 775 ${TCB_BLDDIR}/${PKG}/usr/local/tce.installed
    chown -R root:staff ${TCB_BLDDIR}/${PKG}/usr/local/tce.installed
    echo "#!/bin/sh" >> ${TCB_BLDDIR}/${PKG}/usr/local/tce.installed/${PKG}
    [ -z "${SS1}" ] && export SS1=${TCB_BLDDIR}/${PKG}/usr/local/tce.installed/${PKG} && DONE=1 && log 0 "Created start script $SS1."
    [ -z "${DONE}" ] && [ -z "${SS2}" ] && export SS2=${TCB_BLDDIR}/${PKG}/usr/local/tce.installed/${PKG} && DONE=1 && log 0 "Created start script $SS2."
    [ -z "${DONE}" ] && [ -z "${SS3}" ] && export SS3=${TCB_BLDDIR}/${PKG}/usr/local/tce.installed/${PKG} && DONE=1 && log 0 "Created start script $SS3."
    [ -z "${DONE}" ] && [ -z "${SS4}" ] && export SS4=${TCB_BLDDIR}/${PKG}/usr/local/tce.installed/${PKG} && DONE=1 && log 0 "Created start script $SS4."
    [ -z "${DONE}" ] && log 2 "No more free start scripts!"
  fi
}

rename_config_files () {
	# renaming config files so that they are writable for user
	# renaming mandatory config files and edit start script of extension
	# to automatically copy one file to system
	if [ -n "${CONF_MASK}" ];then
	  for conffile in `find ${TCB_BLDDIR}/${PACKAGE} ${CONF_MASK}`
	  do
	    cfile=$(basename $conffile)
	    echo -e "${YELLOW} * Renaming ${BLUE}$cfile ${YELLOW}to ${WHITE}$cfile.sample.${NORMAL}\t\t\t"
	    mv $conffile $conffile.sample 2>/dev/null
	  done
	fi  
	if [ -n "${CONF_MAND_MASK}" ];then
	  for conffile in `find ${TCB_BLDDIR}/${PACKAGE} ${CONF_MAND_MASK}`
	  do
	    [ -z "${DONE}" ] && create_start_script $1
	    DONE=1
	    cfile=$(basename $conffile)
	    echo -e "${YELLOW} * Renaming ${BLUE}$cfile ${YELLOW}to ${WHITE}$cfile.sample.${NORMAL}\t\t\t"
	    echo -e "${YELLOW} * Putting ${WHITE}$cfile ${YELLOW}to startup script.${NORMAL}\t\t\t"
	    mv $conffile $conffile.sample 2>/dev/null
	    relfile=`echo $conffile | sed "s%${TCB_BLDDIR}/${PACKAGE}%%"`
	    echo "[ ! -e $relfile ] && busybox cp $relfile.sample $relfile" >> ${SS1}
	  done
	fi  
}

work_build () {
  cd ${TCB_BLDDIR}
  # strip and or compress executable files
  strip_compress_files
  # Remove man and doc or let it be
  # First: compress man pages
  for mandir in `find ${TCB_BLDDIR}/${PACKAGE} -type d -name man`; do
    for manfile in `find $mandir -type f -name *.1 -o -name *.2 -o -name *.3 -o -name *.4 -o -name *.5 -o -name *.6 -o -name *.7 -o -name *.8`; do
      log 0 "Compressing man file $manfile."
      eval "${COMPRESSOR} $manfile"
    done
  done
  # debug package
  if [ -n "${DBG_PKG}" ]; then
    log 0 "Creating debug extension ${PACKAGE}-dbg."
    to_new_extension "-name *.dbg" "${PACKAGE}-dbg" "${PACKAGE} gdb"
  fi
  # Check for removing, excorp., etc.
  if [ -n "${DOC_MASK}" ];then
    if [ "${DOC_MASK}" = "remove" ];then
      find ${TCB_BLDDIR}/${PACKAGE} -type d -a \( -name man -o -name manual -o -name info -o -name doc \) | xargs rm -rf 
    else
      log 0 "Creating doc extension ${PACKAGE}-doc."
      to_new_extension "${DOC_MASK}" "${PACKAGE}-doc" "${PACKAGE} man"
    fi
  fi
  # Renaming confs
  rename_config_files ${PACKAGE}
  # Splitting into dev and main
  if [ -n "${DEV_MASK}" ];then
    log 0 "Creating dev extension ${PACKAGE}-dev."
    to_new_extension "${DEV_MASK}" "${PACKAGE}-dev" "${PACKAGE}"
  fi	
  # excorporating locale
  if [ -n "${LOCALE_MASK}" ];then
    log 0 "Creating locale extension ${PACKAGE}-locale."
    to_new_extension "${LOCALE_MASK}" "${PACKAGE}-locale" "${PACKAGE}"
  fi
  # rm empty dirs
  remove_empty_dirs "${TCB_BLDDIR}"
  # copy license and author files 
  install_license ${PACKAGE}
}

remove_empty_dirs() {
  # $1 should be build dir
  find $1 -depth -type d -not -name "src" -empty -exec echo "Removing empty {}." >> $LOGFILE \; -a -exec rmdir {} \;
}

package_build () {
        mkdir -p ${TCB_BLDDIR}/src/${PACKAGE}
	cd ${TCB_BLDDIR}
	for i in $(find `ls` -maxdepth 0 -type d -not -name "src" | cut -d'/' -f1); do
	  # deps
	  RUN_DEPSA="${RUN_DEPS}"
	  # checking for perl dep
	  if [ -z "${NO_PERL}" ];then
	    [ `check_perl $i` -eq 0 ] && RUN_DEPSA="${RUN_DEPS} perl5"
	  fi
	  if [ "$i" = "${PACKAGE}" ];then
	    for each in ${RUN_DEPSA}; do echo -n -e "${each}.tcz\n" | sed "s:${RELEASE}:KERNEL:" >> $i.tcz.dep; done
	  fi
  	  # check running deps 
	  check_run_deps ${i}
	  # fitting in description, first normal package, then dev, locale, doc
	  [ "$i" = "${PACKAGE}" ] && DESCRIPTIONA="${DESCRIPTION}"
    	  [ -n "`echo $i | grep '\-dev'`" ] && DESCRIPTIONA="${DESCRIPTION} - dev files"
	  [ -n "`echo $i | grep '\-locale'`" ] && DESCRIPTIONA="${DESCRIPTION} - locale data"
	  [ -n "`echo $i | grep '\-doc'`" ] && DESCRIPTIONA="${DESCRIPTION} - doc files"
	  [ -n "`echo $i | grep '\-lib'`" ] && DESCRIPTIONA="${DESCRIPTION} - library files"
	  [ -n "`echo $i | grep '\-dbg'`" ] && DESCRIPTIONA="${DESCRIPTION} - debuginfo files"
	  [ -n "`echo $i | grep '\-bin'`" ] && DESCRIPTIONA="${DESCRIPTION} - binary files"
	  if [ -z "${DESCRIPTIONA}" ];then
	    # non standard package
	    DESCRIPTIONA="$i - extension made from ${PACKAGE}"
	  fi
	  if [ -z "${NO_OWN_MOD}" ];then
	    chmod -R g-s $i
	    chown -R root:staff $i
	  fi
	  find $i -name tce.installed -exec chmod -R 775 {} \;
	  mksquashfs $i $i.tcz -info 1>>$LOGFILE 2>&1
	  SIZE=`du -h $i.tcz | cut -f 1 2>/dev/null`
	  [ $? -eq 0 ] && echo -e "${YELLOW} * Built extension: \t\t *** ${WHITE}$i.tcz ($SIZE)${YELLOW} ***${NORMAL}" || echo "${RED}Build failed${NORMAL}."
	  md5sum $i.tcz > $i.tcz.md5.txt
	  zsyncmake $i.tcz 1>>$LOGFILE 2>&1
	  find $i ! -type d | sed "s%[a-zA-Z0-9\._\-]*/\(.*\)%\1%" |sort > $i.tcz.list
	  ### License ###
	  if [ -e "${TCB_BLDDIR}/$i/usr/local/share/doc/License/$i.txt" ];then
	    LICENSEA="${LICENSE} (see /usr/local/share/doc/License/$i.txt)"
	  elif [ -e "${TCB_BLDDIR}/$i/usr/local/share/doc/License/$i-copying.txt" ];then
	    LICENSEA="${LICENSE} (see /usr/local/share/doc/License/$i-copying.txt)"
	  else
	    LICENSEA="${LICENSE}"
	  fi
	  ### Authors ### 
	  [ -e "${TCB_BLDDIR}/$i/usr/local/share/doc/License/$i-authors.txt" ] && AUTHORSA="${AUTHORS} (see /usr/local/share/doc/License/$i-authors.txt)" || AUTHORSA="${AUTHORS}"
	  if [ -z "`grep -v local $i.tcz.list`" ];then
	      COMMENTSA="${COMMENTS}
	   	--- 
		This extension is PPI compatible."
	  fi
    cat <<EOF> $i.tcz.info
Title:		$i.tcz
Description:	${DESCRIPTIONA}
Version:	${VERSION}
Author:		${AUTHORSA}
Original-site:	${HOMEPAGE}
Copying-policy:	${LICENSEA}
Size:		${SIZE}
Extension_by:	${MAINTAINER}
Comments:	${COMMENTSA}
Change-log:	${CHANGELOG}
Current:	${CURRENT}
EOF
    # clean up 
    DESCRIPTIONA=""
    COMMENTSA=""
    AUTHORSA=""
    LICENSEA=""
    # removing
    rm -rf $i
  done
  # remove empty dep-auto files from source
  find ${TCB_BLDDIR}/src/${PACKAGE}/ -type f -size 0 -exec rm -f {} \;
  # copy and compress log file
  cp $LOGFILE ${TCB_BLDDIR}/src/${PACKAGE}/${PACKAGE}.log
  xz -z -9 ${TCB_BLDDIR}/src/${PACKAGE}/*.log
  # set user rights to tc user 
  chown -R tc:staff ./*
  if [ -n "${OVERWRITE_LOCAL}" ];then
    for extfile in `find ${TCB_BLDDIR} -name \*.tcz\*` ; do
      extname=`basename $extfile`
      su -c "cp $extfile ${TCE_REPO}/optional/" ${TCUSER}
      chmod 664 ${TCE_REPO}/optional/${extname}
      if [ -n "`echo $extname | grep .tcz.dep`" ];then
        sed -i "s:KERNEL:${RELEASE}:g" ${TCE_REPO}/optional/${extname} 
      fi
    done
  fi
  cd ${TCB_SRCDIR}
  if [ -z "${ORIG_NAME}" ]; then
    cp ${PACKAGE}${SEP}${VERSION}${PKG_EXT} ${TCB_BLDDIR}/src/${PACKAGE}/${PACKAGE}${SEP}${VERSION}${PKG_EXT}
  else
    cp ${ORIG_NAME}${SEP}${VERSION}${PKG_EXT} ${TCB_BLDDIR}/src/${PACKAGE}/${ORIG_NAME}${SEP}${VERSION}${PKG_EXT}
  fi
  cd ${TCB_BLDDIR}/src/${PACKAGE}
  for archive in `ls *`; do
    archext=${archive##*.}
    archname=${archive%.*}
    case $archext in
      gz|tgz) gunzip $archive ;; 
      bz2|tbz2) bunzip2 $archive ;; 
      zip) unzip -d $archname $archive ; tar cf $archname.tar $archname ; rm -f $archive ; archname=$archname.tar ;; 
      *) echo noop >/dev/null ;; 
    esac
    for tarfile in `find . -name *.tar`; do
      echo -e -n "${YELLOW} * Compressing source: ${BLUE}$archname.xz ... \t\t"
      xz -9 -z $tarfile && success || fail
    done
  done 
}

clean_up() {
  # unset vars
  unset PACKAGE ORIG_NAME RENAME_TO CFLAGS CXXFLAGS LDFLAGS CPPFLAGS PKG_CONFIG_PATH LANG LANGUAGE LC_ALL SS1 SS2 SS3 SS4 TCB_SOURCE VERSION PKG_EXT INSTALL_ROOT DESTDIR TCE_REPO LOGFILE
  # Removing dummy files
  for file in ${DUMMY_FILES} ; do
    log 0 "Removing dummy file $file."
    rm $file
  done
}

upload_to_repo() {
  if [ $(online) -eq 0 ] && [ -f "`dirname $1`/my.repo" ];then
    . "`dirname $1`/my.repo"
    huser=`echo $MYREPO | cut -d@ -f1`
    hhost=`echo $MYREPO | cut -d@ -f2 | cut -d: -f1`
    hpath=`echo $MYREPO | cut -d: -f2 | sed 's%~/public_html%%'`
    scp -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -r ${TCB_BLDDIR}/* $MYREPO 1>/dev/null
    [ $? -ne 0 ] && exit 1 
    for ext in `ls ${TCB_BLDDIR}/../*.tar.gz.bfe`;do
      echo "${YELLOW} * Release:${WHITE} http://${hhost}/~${huser}${hpath}/`basename $ext`${NORMAL}"
    done
  fi
}

create_initd_script() {
  # $1 extension name e.g. pcsc-lite
  # $2 path to daemon file e.g. /usr/local/sbin/pcscd
  # $3 user:group for daemon e.g. "pcscd:pcscd"
  # $4 path to pid file e.g. /var/run/pcscd.pid
  # $5 daemon options e.g. "-p /var/run/pcscd.pid -l /var/log/pcscd.log"
  initscript="${TCB_BLDDIR}/$1/usr/local/etc/init.d/`basename $2`"
  if [ -d "${TCB_BLDDIR}/$1" ]; then
    log 0 "Creating initd script: $initscript... "
    mkdir -p `dirname $initscript`
    cat <<EOF> $initscript
#!/bin/sh
DAEMON=$2
DAEMON_NAME=`basename $2`
DAEMON_PIDFILE=$4
DAEMON_OPTS="$5"
DAEMON_USER=`echo $3 | cut -d: -f1`
DAEMON_GROUP=`echo $3 | cut -d: -f2`
start() {
  if [ -x \${DAEMON} ] && [ ! -e \${DAEMON_PIDFILE} ]; then
    mkdir -p \$(dirname \${DAEMON_PIDFILE}) 2>/dev/null
    echo Starting \${DAEMON_NAME}...
    \${DAEMON} \${DAEMON_OPTS}
  fi 
}
stop() {
  if [ -e \${DAEMON_PIDFILE} ] || [ -n "\$(pidof \${DAEMON_NAME})" ]; then
    echo Stopping \${DAEMON_NAME}...
    kill \$(cat \${DAEMON_PIDFILE})
    if [ \$? -ne 0 ]; then
      killall \${DAEMON_NAME}
      rm -f \${DAEMON_PIDFILE} 2>/dev/null
    fi 
    sleep 1
  fi 
}
status() {
  RUNNING=\$(pidof \${DAEMON_NAME})
  if [ -z "\${RUNNING}" ]; then
    echo "Running no \${DAEMON_NAME} services."
  else
    echo Running \${DAEMON_NAME} services with pids: \$(pidof \${DAEMON_NAME}).
  fi
}
case \$1 in
  start) start ;;
  stop) stop ;;
  restart) stop ; start ;;
  status) status ;;
  *) echo "Usage: \$0 [start|stop|restart|status]" ;;
esac
EOF
    chmod 755 $initscript
  fi
}

create_wbar_icon() {
  # $1 - package name
  # $2 - icon path (will be renamed)
  # $3 - command to execute
  if [ -n "$1" ] && [ -n "$2" ] && [ -n "$3" ];then
    mkdir -p ${TCB_BLDDIR}/$1/usr/local/share/applications 2>/dev/null
    mkdir -p ${TCB_BLDDIR}/$1/usr/local/share/pixmaps 2>/dev/null
    FEXT=${2##*.}
    cp "$2" "${TCB_BLDDIR}/$1/usr/local/share/pixmaps/$1.${FEXT}"
    cat <<EOF> ${TCB_BLDDIR}/$1/usr/local/share/applications/$1.desktop
[Desktop Entry]
Type=Application
Name=$1
Exec=$3
Icon=$1
X-FullPathIcon=/usr/local/share/pixmaps/$1.${FEXT}
Categories=GNOME;Network;
EOF
  fi
}

############## run script #################
init_build "$DESCFILE"
get_source
if [ $(fn_exists configure_special_source) -eq 0 ];then
  echo -e -n "${YELLOW} * Editing source... \t\t\t\t\t\t"
  configure_special_source
fi
configure_source
make_build
work_build
if [ $(fn_exists work_special_build) -eq 0 ];then
  echo -e -n "${YELLOW} * Special adjustments... \t\t\t\t\t"
  work_special_build
fi
package_build
clean_up
upload_to_repo $0

########### end of script ##############