#!/bin/bash
#SDCARDDIR=/media/linuxroot
SDCARDDIR=/media/$USERNAME/linuxroot
RED='\e[1;31m'
GREEN='\e[1;32m'
CYAN='\e[1;36m'
NC='\e[0m'
BOOTSTRAP=qemu-debootstrap	# Datei muss vorhanden sein
QEMU=qemu-user-static  		# Paketname für qemu-debootstrap
BINFMT=binfmt-support  		# Datei muss vorhanden sein
DEBOOTSTRAP=debootstrap 	# Paketname für binfmt-support
GIT=git 			# git Client für Kernel-Sourcecode download
SHARUTILS=sharutils
LIBUSBDEV=libusb-1.0-0-dev	# libusb
CROSSCOMPILER_DEB=gcc-arm-linux-gnueabihf # Paket des Crosscompilers
#CROSSCOMPILER=arm-linux-gnueabihf-gcc-4.7 # Crosscompiler für ARM-Architektur; wird nur bei älteren Version <4.8 benötigt
BESSENTIAL=build-essential
LIBNCURSES=libncurses5-dev
ARCH=armhf
VARIANT=minbase

HOMEDIR=`pwd` # akutelles Home-Verzeichnis; Start-Pfad, in den der Unterordner "minix" erstellt wird

WORKDIR=minix
BASEDIR=${HOMEDIR}/$WORKDIR
ROOTFSDIR=${BASEDIR}/$WORKDIR-rootfs
KERNELDIR=${BASEDIR}/$WORKDIR-kernel
ANDROIDDIR=${BASEDIR}/android/tools
ADBDIR=${BASEDIR}/android/platform-tools
KERNELNAME=rk3066-kernel

KERNELCONFIG=.config_minix_neo_x5_20131018 # Konfiguration für Kernel-Compile

# Konfiguration des Minix System
MINIXROOTUSER=root 	# setzen des sudo-User des minix;
MINIXHOSTNAME=minix 	# Systemname des minix
MINIXSSID=wlanssid	# WLAN SSID des minix
MINIXPSK=wlanpass		# WLAN PSK des minix
# Liste mit zusätzlichen Tools, die auf dem Minix Neo installiert werden sollen.
MINIXEXTRATOOLS="nano,openssh-server,ifupdown,netbase,net-tools,isc-dhcp-client,keyboard-configuration,vim,sudo"

DIST_MAIN=debian	# debian oder ubuntu als Zielsystem festlegen; Version wird unten über UBUNTU_VERSION bzw. DEBIAN_VERSION festgelegt; wenn LEER, dann wird der Wert erfragt
DIST_VERSION=wheezy 	# percise für Ubuntu 12.04 ODER wheezy für Debian 7.0; wenn leer, dann wird der Wert erfragt

MIRROR=empty
SOURCES=empty
# Parameter für Minix Neo System konfigurieren
# Ubuntu 12.04 Precise Pangolin  

if [ -z $DIST_MAIN ] || [ -z $DIST_VERSION ] 
then
  echo -e "Betriebssystem wählen ${GREEN}ubuntu${NC} oder ${GREEN}debian${NC}; [default: ${RED}debian${NC}]"
  read -p "Wahl :" choice
    case "$choice" in 
      ubuntu|UBUNTU )
        DIST_MAIN=ubuntu
        echo -e "Ubuntu-Distribution angeben; [Default: ${RED}precise${NC}]"
        read -p "Wahl :" choice
          if [ $choice ]
          then DIST_VERSION=${choice}
          else DIST_VERSION=precise
          fi
      ;;
      * ) 
        DIST_MAIN=debian
        echo -e "Debian-Distribution angeben; [Default: ${RED}wheezy${NC}]"
        read -p "Wahl :" choice
          if [ $choice ]
          then DIST_VERSION=${choice}
          else DIST_VERSION=wheezy
          fi
      ;;
  esac
echo "Distribution: $DIST_MAIN und $DIST_VERSION ausgewählt."
fi

MIRROR_UBUNTU=http://ports.ubuntu.com
SOURCES_UBUNTU="deb $MIRROR_UBUNTU/ubuntu-ports/ $DIST_VERSION main restricted universe multiverse
deb-src $MIRROR_UBUNTU/ubuntu-ports/ $DIST_VERSION main restricted universe multiverse
deb $MIRROR_UBUNTU/ubuntu-ports/ $DIST_VERSION-updates main restricted universe multiverse
deb-src $MIRROR_UBUNTU/ubuntu-ports/ $DIST_VERSION-updates main restricted universe multiverse
deb $MIRROR_UBUNTU/ubuntu-ports/ $DIST_VERSION-security main restricted universe multiverse
deb-src $MIRROR_UBUNTU/ubuntu-ports/ $DIST_VERSION-security main restricted universe multiverse"

# Debian 7.0 Wheezy
MIRROR_DEBIAN=http://ftp.de.debian.org/debian
SOURCES_DEBIAN="deb $MIRROR_DEBIAN $DIST_VERSION main contrib non-free
deb-src $MIRROR_DEBIAN $DIST_VERSION main contrib non-free"

# Variablen für Distributionsauswahl vorbereiten.
case "$DIST_MAIN" in
  debian)
  DIST=$DIST_VERSION
  MIRROR=$MIRROR_DEBIAN
  SOURCES=$SOURCES_DEBIAN
  ;;
  ubuntu)
  DIST=$DIST_VERSION
  MIRROR=$MIRROR_UBUNTU
  SOURCES=$SOURCES_UBUNTU
  ;;
esac

[ $UID -ne 0 ] && { 
    echo -e "${RED}Fehler: Das Script benötigt root-Rechte.${NC}"
    echo -e "Aufruf mit \"${GREEN}sudo $0${NC}\""
    exit 1
}

# Arbeitsarchive sichern
alles_packen() {
echo -e "Packe rootfs und kernel in ${GREEN}minix.tar.bz2${NC}"
cd $HOMEDIR
cp $HOMEDIR/${0} $WORKDIR
tar -cvjf minix.tar.bz2 $WORKDIR
}

# Arbeitsarchive wiederherstellen
alles_auspacken() {
echo -e "Packe ${GREEN}minix.tar.bz2${NC} aus nach ${GREEN}$WORKDIR${NC}"
if [ -d $WORKDIR ]
then 
  echo -e "${RED}Fehler${NC}: Ordner ${RED}$WORKDIR${NC} existiert schon!"
  read -p "Überschreiben [j|N]: " choice
   case "$choice" in 
   j|J ) 
     rm -rf $WORKDIR;;
   * ) 
     echo -e "Nichts passiert. ${GREEN}OK${NC}."
     exit 1
     ;;
   esac
fi
echo -e "Erstelle ${RED}$WORKDIR${NC}."
mkdir $WORKDIR
tar -xvjf minix.tar.bz2
echo -e "Alles ausgepackt. ${GREEN}OK${NC}."
}

# System vorbereiten
prepare() {
echo -e "-------- BEGIN Vorbereitungen (${CYAN}prepare${NC}) ---------"
if [ -z $(which ${BOOTSTRAP}) ] || [ -z $(which /usr/sbin/update-binfmts) ] || [ -z $(which ${DEBOOTSTRAP}) ]
then
  echo -e "Installiere ${RED}${QEMU} ${BINFMT} ${DEBOOTSTRAP}${NC}."
  apt-get update
  apt-get -y install $QEMU $BINFMT $DEBOOTSTRAP
else
  echo -e "${BOOTSTRAP} ${BINFMT} und ${DEBOOTSTRAP} sind bereits installiert. ${GREEN}OK${NC}."
fi
 # extra build tools

if [ -z $(which ${GIT}) ] || [ -z $(which arm-linux-gnueabihf-gcc) ] || [ ! -e /usr/share/build-essential/essential-packages-list ] || [ -z $(which uudecode) ] || [ ! -d /usr/include/libusb-1.0 ]
then
  echo -e "Installiere ${RED}${GIT}, ${CROSSCOMPILER_DEB}, ${SHARUTILS}, ${LIBUSBDEV} und ${BESSENTIAL}${NC}." 
  apt-get update
  apt-get -y install $GIT $CROSSCOMPILER_DEB $SHARUTILS $LIBUSBDEV $BESSENTIAL
# gcc wird als arm-linux-gnueabihf-gcc-4.7 installiert, make erwartet aber arm-linux-gnueabihf-gcc
# LÖSUNG: sym-link anlegen
#  ln -s $(dirname `which $CROSSCOMPILER`)/$CROSSCOMPILER /usr/bin/arm-linux-gnueabihf-gcc
else
  echo -e "${GIT}, ${CROSSCOMPILER}, ${SHARUTILS}, ${LIBUSBDEV} und ${BESSENTIAL} sind bereits installiert. ${GREEN}OK${NC}."  
fi

#ncurses für make menuconfig
if [ ! -e /usr/include/curses.h ]
then
  echo -e "Installiere ${RED}${LIBNCURSES}${NC}."
  apt-get -y install $LIBNCURSES
else
  echo -e "${LIBNCURSES} ist bereits installiert. ${GREEN}OK${NC}."
fi

if [ ! -d $BASEDIR ] 
then
  echo -e "Arbeitsverzeichnis werden erstellt. ${RED}$BASEDIR${NC}."
  mkdir $BASEDIR && mkdir $KERNELDIR && mkdir $ROOTFSDIR && mkdir ${KERNELDIR}/kernel_mod
  chown -R $SUDO_USER:$SUDO_USER $BASEDIR
else
  echo -e "Arbeitsverzeichnis existiert bereits. ${GREEN}OK${NC}."
fi
echo -e "-------- END Vorbereitungen (${CYAN}prepare${NC}) ---------"
}


# rootFS anlegen
bootstrap() {
echo -e "-------- BEGIN RootFS erzeugen (${CYAN}bootstrap${NC}) ---------"
echo -e "${RED}Boootstrap anlegen.${NC}"
cd $ROOTFSDIR
pwd
$BOOTSTRAP --verbose --no-check-gpg --variant=$VARIANT --include=$MINIXEXTRATOOLS --arch=$ARCH $DIST $ROOTFSDIR $MIRROR
echo -e "-------- END RootFS erzeugen (${CYAN}bootstrap${NC}) ---------"
}


# Neuen recovery.img Kernel bauen
kernel() {
echo -e "-------- BEGIN recovery.img Kernel erzeugen (${CYAN}kernel${NC})---------"
echo -e "Kernel ${RED}herunterladen/bauen${NC}"
cd $KERNELDIR

#Kernel sourcen schon vorhanden? Sonst herunterladen
if [ ! -d rk3066-kernel ]
then
  echo -e "Hole ${RED}rk3066-kernel${NC}!"  
  git clone --depth 1 https://github.com/Myria-de/rk3066-kernel-minix-neo-x5 rk3066-kernel
else
  echo -e "rk3066-kernel ist bereits vorhanden. ${GREEN}OK${NC}."
fi

#initramfs
if [ ! -d initramfs ]
then
  echo -e "Hole ${RED}initramfs${NC}!"
  git clone --depth 1 https://github.com/Galland/rk30_linux_initramfs.git initramfs
  cd initramfs
  gzip -dc debian-3.0.8+fkubi.cpio.gz > initramfs.cpio
else
  echo -e "initramfs ist bereits vorhanden. ${GREEN}OK${NC}."
fi

# kernel schon vorhanden?
BUILDKERNEL=yes
if [ -e ${KERNELDIR}/${KERNELNAME}/arch/arm/boot/zImage ]
then
  read -p "Kernel-Image existiert bereits. Neu erstellen (j/N)?" choice
   case "$choice" in 
   j|J ) BUILDKERNEL=yes;;
   * ) BUILDKERNEL=no;;
   esac
fi

#kernel erstellen
if [ ${BUILDKERNEL} == yes ]
then
  echo -e "Baue ${RED}kernel${NC}!"
  cd ${KERNELDIR}/${KERNELNAME}
# Compiler Parameter setzen
  export ARCH=arm
  export CROSS_COMPILE=arm-linux-gnueabihf-
  export INSTALL_MOD_PATH=${KERNELDIR}/kernel_mod
  export KDIR=./
  export LOCALVERSION=""
  MAKE="make -j$(getconf _NPROCESSORS_ONLN)"
  $MAKE mrproper
  cp $KERNELCONFIG .config # Default-Konfiguration für Kernel-Compile setzen
  #cp config.pcw .config
  $MAKE
  $MAKE modules_install
else
  echo -e "Existierender kernel wird verwendet. ${GREEN}OK${NC}."
fi

# mkbootimge für das Erstellen von recovery.img 
if [ ! -d ${KERNELDIR}/tools ]
then
  echo -e "Hole ${RED}mkbootimge!${NC}!"
  cd ${KERNELDIR}
  git clone --depth 1 https://github.com/olegk0/tools.git 
else
  echo -e "mkbootimge ist bereits vorhanden. ${GREEN}OK${NC}."
fi

#rkflashtool zum Flashen von recovery.img
cd ${KERNELDIR}
if [ ! -d ${KERNELDIR}/rkflashtool ]
then
echo -e "Hole ${RED}rkflashtool_rk3066${NC}!"
git clone --depth 1 https://github.com/Galland/rkflashtool_rk3066.git rkflashtool
cd ${KERNELDIR}/rkflashtool
if [ -e flash_kernel.sh ]
then 
  rm flash_kernel.sh
  echo "flash_kernel.sh vorsichtshalber gelöscht!"  # mit falschen Parameter kann es den minix zerstören
  echo -e "statt flash_kernel.sh bitte ${GREEN}flash2minix.sh${NC} nutzen."
fi

make
if [ -e ${KERNELDIR}/rkflashtool/rkflashtool ]
then
  echo -e "rkflashtool erfolgreich erstellt. ${GREEN}OK${NC}." 
  else
  echo -e "${RED}Fehler konnte rkflashtool nicht erstellen!${NC}" 
  fi
else
  echo -e "rkflashtool ist bereits vorhanden. ${GREEN}OK${NC}."
fi

echo -e "Erstelle ${RED}recovery.img${NC}!"
cd ${KERNELDIR}/tools
./mkbootimg --kernel ${KERNELDIR}/${KERNELNAME}/arch/arm/boot/zImage \
--ramdisk ${KERNELDIR}/initramfs/fakeramdisk.gz --base 60400000 \
--pagesize 16384 --ramdiskaddr 62000000 \
-o ${KERNELDIR}/recovery.img
cd ${KERNELDIR}
if [ -e ${KERNELDIR}/recovery.img ]
then
  echo -e "recovery.img erfolgreich erstellt. ${GREEN}OK${NC}."
  mv ${KERNELDIR}/recovery.img ${KERNELDIR}/rkflashtool/recovery.img
else
  echo -e "${RED}Fehler: recovery.img wurde nicht erstellt!${NC}"
fi
echo -e "-------- END recovery.img Kernel erzeugen (${CYAN}kernel${NC}) ---------"
}

#copy files to SD card $SDCARDDIR /media/linuxroot
copy_files() {
echo -e "-------- BEGIN Dateien auf SD-Karte (${CYAN}copy2sd${NC}) ---------"
echo "Dateien auf SD-Karte kopieren"
if [ -d ${SDCARDDIR} ]
then
  echo -e "Kopiere ${RED}rootfs${NC}!"
  cp -av ${ROOTFSDIR}/* ${SDCARDDIR}
  echo -e "Kopiere ${RED}Kernel-Module${NC}"
  cp -av ${KERNELDIR}/kernel_mod/* ${SDCARDDIR}
  echo -e "Kopieren beendet. ${GREEN}OK${NC}."
else
 echo -e "${RED}Fehler: Verzeichnis ${SDCARDDIR} existiert nicht. Bitte SD-Karte einhängen.${NC}"
fi
echo -e "-------- END Dateien auf SD-Karte (${CYAN}copy2sd${NC}) ---------"
}

# recovery.img auf minix flashen
flash_recovery() {
if [ -d ${KERNELDIR}/rkflashtool ]
then
cd ${KERNELDIR}/rkflashtool
#flash2minix.sh erstellen
echo -e "${RED}flash2minix.sh${NC} generieren. Wird zum flashen des neuen Kernels verwendet."
cat<<EOF>flash2minix.sh
#!/bin/bash
# Machine-Model:	NEO-X5-116A
# Machine-ID: 		007
# Manufactorer: 	RK30SDK
# 
# Partitionmap 
# Partition	@Addr		length
# misc		0x2000		0x2000
# kernel	0x4000		0x6000
# boot		0xA000		0x8000
# recovery	0x12000		0x8000
# backup	0x1A000		0xC0000
# cache		0xDA000		0x40000
# userdata	0x11A000	0x800000
# kpanic	0x91A000	0x2000
# system	0x91C000	0x100000
# syntax: rkflashtool w ADDR LEN < IMG_NAME.img
# example: flash w 0x12000 0x8000 < recovery.img
RED='\e[1;31m'
GREEN='\e[1;32m'
NC='\e[0m'

if [ -f recovery.img ]; 
then
  echo -e "\${RED}ACHTUNG: Die Startwerte MÜSSEN korrekt sein!\${NC}"
  echo "Wenn die Adresse oder der Offset falsch ist, dann kann das Gerät beschädigt werden!"
  echo "Lese Speicher von Minix aus!!"
  sudo ./rkflashtool r 0x0 0x1 > read.img
  echo -e "Dump-Format:              \${GREEN}OFFSET@ADRESSE(NAME)\${NC}"
  echo -e "Dump des Minix-Speichers:\${RED} \c"
  cat read.img | strings | grep --color -Po '(?<=\(boot\)\,).*(?=\(backup)' | grep -Po '^.*(?=\,)' 
  echo -e "\${NC}Ermittelte Werte für den Flash-Vorgang:"
  offset=\$(cat read.img | strings | grep -Po '(?<=\(boot\)\,).*(?=\(recovery)' | grep -o '^0x[0-9]\{8\}') 
  addr=\$(cat read.img | strings | grep -Po '(?<=\(boot\)\,).*(?=\(recovery)' | grep -o '0x[0-9]\{8\}\$')

  rm read.img
  echo "Ermittelte Werte für recovery.img:"  
  echo -e "Größe Image   : \${GREEN}\$offset\${NC}"
  echo -e "Start-Adresse : \${GREEN}\$addr\${NC}"
  echo -e "\${GREEN}Verwende folgenden Befehl zum Flashen:\${RED}"
  echo -e "\${RED}./rkflashtool w \$addr \$offset < recovery.img\${NC}"
  read -p "Parameter korrekt? [j|N]" choice
  case "\$choice" in 
    j|J ) 
      echo -e "\\n\${RED}!!Gerät nicht abschalten schreibe image!!\${NC}"
      echo -e "./rkflashtool w \$addr \$offset < recovery.img"
      sudo ./rkflashtool w \$addr \$offset < recovery.img
  ;;
  * ) echo -e "Nichts passiert. \${GREEN}OK\${NC}."
  ;;
  esac
else
  echo -e "Es muss zunächst ein kernel übersetzt werden und eine gültige \${GREEN}recovery.img\${NC} Datei existieren,"
  echo "um dieses Skript zu nutzen!"
fi
EOF
chmod +x ${KERNELDIR}/rkflashtool/flash2minix.sh
./flash2minix.sh
else
  echo -e "${RED}Fehler:${NC} rkflashtool nicht installiert!"
fi
}


# in neues rootFS wechseln und letzte Änderungen vornehmen
rootfs() {
echo -e "-------- BEGIN In rootFS wechseln (${CYAN}rootfs${NC}) ---------"
echo "Rootfs bearbeiten"

chmod 755 ${ROOTFSDIR}/install_tools.sh
chmod 755 ${ROOTFSDIR}/config_keyboard.sh

mount -t proc proc ${ROOTFSDIR}/proc
mount -t sysfs sysfs ${ROOTFSDIR}/sys
mount -o bind /dev ${ROOTFSDIR}/dev
mount -t devpts devpts ${ROOTFSDIR}/dev/pts
echo -e "${GREEN}Wechsele in ${ROOTFSDIR}${NC}." 
echo -e "Bitte nach dem Wechsel ${RED}install_tools.sh${NC} und ${RED}config_keyboard.sh${NC} aufrufen."
echo -e "Mit ${RED}exit${NC} kann ins Hauptsystem zurückgewechselt werden."
chroot ${ROOTFSDIR}
# mountpoints wieder entfernen
umount ${ROOTFSDIR}/proc
umount ${ROOTFSDIR}/sys
umount ${ROOTFSDIR}/dev/pts
umount ${ROOTFSDIR}/dev
echo -e "Willkommen zurück im ${RED}Hauptsystem${NC}."
echo -e "-------- END rootFS vorbereiten (${CYAN}rootfs${NC}) ---------"
}

# rootFS Grundkonfiguration vornehmen
prepare_rootfs() {
echo -e "-------- BEGIN Vorbereitung rootFS (${CYAN}prepare_rootfs${NC}) ---------"
echo "Bereite rootfs vor"

# Paketquellen konfigurieren
echo -e "Lege Paketquellen fest für minix (${RED}$DIST_MAIN${NC} / ${RED}$DIST${NC})"
cat<<EOF>${ROOTFSDIR}/etc/apt/sources.list
$SOURCES
EOF

#Hostname setzen
echo -e "Hostname für minix in ${RED}/etc/hostname${NC} auf ${RED}$MINIXHOSTNAME${NC} setzen."
echo ${MINIXHOSTNAME} >  ${ROOTFSDIR}/etc/hostname
echo "127.0.1.1 ${MINIXHOSTNAME}" >>  ${ROOTFSDIR}/etc/hosts

#fstab
echo -e "Mountpoints für minix in ${RED}/etc/fstab${NC} setzen."
cat<<EOF>${ROOTFSDIR}/etc/fstab
/dev/root / ext4 defaults,noatime 0 0
tmpfs    /var/log    tmpfs    defaults    0 0
tmpfs    /tmp        tmpfs    defaults    0 0
tmpfs    /var/tmp    tmpfs    defaults    0 0
EOF

#Netzwerk setup
echo -e "Netzwerk für minix ${RED}/etc/network/interfaces${NC} setzen."
cat<<EOF>${ROOTFSDIR}/etc/network/interfaces
auto lo
iface lo inet loopback
# Ethernet interface eth0 
auto eth0
iface eth0 inet dhcp

# WLAN interface eth1
#auto eth1
#iface eth1 inet dhcp
#wpa-ssid $MINIXSSID
#wpa-psk $MINIXPSK
EOF

echo -e "Nameserver aus Hauptsystem ${RED}/etc/resolve.conf${NC} für minix setzen."
cp -L /etc/resolv.conf ${ROOTFSDIR}/etc/resolv.conf

# Installationsskript install_tools.sh und in rootFS ablegen. Muss nach chroot aufgerufen werden!
echo -e "Installtionsskript ${RED}install_tools.sh${NC} anlegen. MUSS NACH ${RED}chroot${NC} aufgerufen werden!"
cat<<EOF>${ROOTFSDIR}/install_tools.sh
PURP='\e[1;35m'
CYAN='\e[1;36m'
NC='\e[0m'
echo -e "Installiere Tools im \${PURP}rootfs\${NC}."
export LANG=C
apt-get update
apt-get -y install apt-utils dialog locales
cat <<END > /etc/apt/apt.conf.d/71neo
APT::Install-Recommends "0";
APT::Install-Suggests "0";
END
# Sprache auf deutsch wechseln
cat <<END > /etc/locale.gen
de_DE.UTF-8 UTF-8
END
export LANG=de_DE.UTF-8
locale-gen de_DE.UTF-8
dpkg-reconfigure locales
localedef -i de_DE -c -f UTF-8 de_DE.UTF-8 

# Fallunterscheidung, weil firmware-Paket bei Ubuntu anders heisst als bei Debian
if grep -iq "ubuntu" /etc/issue
then
  apt-get -y install sudo udev iproute iputils-ping wget ntpdate ntp vim less most tzdata console-tools console-data console-common module-init-tools linux-firmware
else
  apt-get -y install sudo udev iproute iputils-ping wget ntpdate ntp vim less most tzdata console-tools console-data console-common module-init-tools firmware-linux-free firmware-linux-nonfree
fi

echo -e "Bitte geben Sie das \${PURP}Passwort\${NC} und die \${PURP}Daten\${NC} für den \${PURP}neuen root-Benutzer\${NC} ein."
adduser $MINIXROOTUSER
adduser $MINIXROOTUSER sudo
EOF

# Installationsskript config_keyboard.sh und in rootFS ablegen. Muss nach chroot aufgerufen werden!
echo -e "Installtionsskript ${RED}config_keyboard.sh${NC} anlegen. MUSS NACH ${RED}chroot${NC} aufgerufen werden!"
cat<<EOF>${ROOTFSDIR}/config_keyboard.sh
dpkg-reconfigure tzdata
dpkg-reconfigure console-data
dpkg-reconfigure console-common
dpkg-reconfigure keyboard-configuration
EOF

echo -e "-------- END Vorbereitung rootFS (${CYAN}prepare_rootfs${NC}) ---------"
}

hilfe() {
cat <<EOF
Aufruf: sudo $0 OPTION

Optionen:
prepare .... System vorbereiten, nötige Pakete installieren
bootstrap .. System vorbereiten (prepare) und Dateien für rootfs herunterladen (bootstrap)
kernel ..... Kernel herunterladen und compilieren
chrootfs ... mit chroot in das rootfs wechseln und das minix-system vorkonfigurieren
mksystem ... führt prepare, bootstrap, chrootfs und kernel nacheinander aus

copy2sd .... System auf SD-Karte kopieren
flash2minix. recovery.img in minix Speicher flashen
packen ..... $WORKDIR für Backup in Datei minix.tar.bz2 packen
auspacken .. Backup minix.tar.bz2 in den Ordner $WORKDIR auspacken
adb ........ Android-SDK installieren

help ....... diese Hilfe anzeigen

Beispiel für mksystem:
EOF
echo -e "${RED}sudo $0 mksystem${NC}"
}

# Android Tools installieren, zu Fernsteuerung des Minix Neo per Linux-Terminal
install_adb() {
apt-get --no-install-recommends install openjdk-7-jre
if !(uname -m | grep -i 32)
then
  echo -e "Aktuelles System ist kein 32-bit-System. Android-Umgebung benötigt ia32-libs. Wird installiert."
  apt-get install ia32-libs
fi
cd $BASEDIR
wget -c http://dl.google.com/android/android-sdk_r22.3-linux.tgz
tar zxvf android-sdk_r22.3-linux.tgz
mv android-sdk-linux $BASEDIR/android
chown -R $SUDO_USER:$SUDO_USER $BASEDIR/android

if [ ! -d ${HOMEDIR}/.android ]
then
  mkdir ${HOMEDIR}/.android
  chown -R $SUDO_USER:$SUDO_USER ${HOMEDIR}/.android
fi 

if [ ! -e ${HOMEDIR}/.android/adb_usb.ini ]
then
cat<<EOF>${HOMEDIR}/.android/adb_usb.ini
# ANDROID 3RD PARTY USB VENDOR ID LIST -- DO NOT EDIT.
# USE 'android update adb' TO GENERATE.
# 1 USB VENDOR ID PER LINE.
0x2207
EOF
  chown $SUDO_USER:$SUDO_USER ${HOMEDIR}/.android/adb_usb.ini
fi

if [ ! -e /etc/udev/rules.d/51-android.rules ]
then
cat<<EOF>/etc/udev/rules.d/51-android.rules
SUBSYSTEM=="usb", ATTR{idVendor}=="2207", MODE="0666"
EOF
  chown root:root /etc/udev/rules.d/51-android.rules
  chmod 644 /etc/udev/rules.d/51-android.rules
  sudo service udev restart 
fi

cd ${ANDROIDDIR}
echo -e "Es werden noch die ADB-Tools benötigt. ${GREEN}Bitte die Lizenzen akzeptieren, damit der Download startet.${NC}"
su $SUDO_USER ./android update sdk --no-ui
}


case "$1" in
  prepare)
  prepare
  ;;
  bootstrap)
  prepare 
  bootstrap
  ;;
  kernel)
  prepare  
  kernel
  ;;
  copy2sd)
  copy_files
  ;;
  flash2minix)
  flash_recovery
  ;;
  packen)
  alles_packen
  ;;
  auspacken)
  alles_auspacken
  ;;
  adb)
  install_adb
  ;;
  chrootfs)
  prepare_rootfs
  rootfs
  ;;
  mksystem)
  prepare
  bootstrap
  prepare_rootfs
  rootfs
  kernel
  ;;
  hilfe)
  hilfe
  ;;
  *)
  hilfe
  ;;
esac
exit 0