#!/system/xbin/bb/sh

msg()   { echo "--------------------------------------" ; echo "+$1" >&2 ; }
warn()  { echo "==WARNING: $1" >&2 ; }
error() { echo >&2 ; echo "===ERROR: $1" >&2 ; exit ; }

used() { du -s "$1" | (read k x; echo $k) ; }
free() { df "$1" |tail -1 | (read x1 x2 x3 k x5; echo $k) ; }

backup_sd_err()
{
  echo "==ERROR: Could not backup $MPF to $1."
  echo

  echo "Check that you have enough space in $1 to fit all of the contents of $MPF.  If not, either delete some files from $MPF or choose a new location for your backup."

  echo

  k=`used "$MPF"`
  echo " Used space on $MPF: ${k}K"

  k=`free "$1"`
  echo " Free space on $1 partition: ${k}K"
  exit
}

backup_sd()
{
  msg "Backing up $MPF to $BDIR"
  [ ! -d "$BDIR" ] && mkdir -p "$BDIR"
  cp -a "$MPF" "$1" && return

  rm -r "$BDIR$MPF"
  backup_sd_err "$1" >&2
}

umount_err()
{
  echo "==ERROR: Could not unmount $MPF!"
  echo
  echo "Perhaps an application is holding a file open?  Stop running applications and try again!"
  echo
  exit
}

fdiska()
{ # line ...
  (while [ $# -gt 0 ] ; do echo "$1" ; shift ; done) | { fdisk "$DEV" || return 1 ; }
  return 0
}

partition()
{
  msg "Partitioning sdcard"
  x=`df|grep "^$MPF":`
  [ ! -z "$x" ] && { umount "$MPF" || umount_err >&2 ; }

  # My 1 GB Card:
  # /dev/block/mmcblk0p1               1       31000      991992   6 FAT16

  msg " Backup partition table/wipe/create FAT$FAT $FSIZE/create EXT2 $ESIZE"
  fbackup "$BAKP"
  fdiska p q > "$BAKP"

  # Separating these steps causes problems.  It appears that as soon
  # as the partition table is written, the /sdcard gets mounted. This
  # then prevents any more partitions from being created.
  [ ! -z "$ESIZE" ] && ESIZE="+$ESIZE"
  fdiska o   n p 1 '' "+$FSIZE"   t "$FT"  p   n p 2 '' "$ESIZE"   t 2 83  p  w || error "Unable to create new partitions"

  sleep 3
  # Seems like the phone mounts this automatically in read only mode 
  # if fs is sane? This can prevent a mkdosfs
  umount "$MPF"
}

mkfses()
{
  msg "Creating FAT$FAT Filesystem"
  mkdosfs -F "$FAT" "$DEV1"

  msg "Creating EXT2 Filesystem"
  "$MKFS" "$DEV2"
}

yN() { read r ; [ "$r" = "y"  -o  "$r" = "Y"  -o  "$r" = "yes"  -o  "$r" = "YES" ] ; }

lcp()
{
  while read f ; do
    cp -dr "$BDIR$MPF/$f" "$MPF" || err=1
  done
  echo "Permission setting errors are normal on a FAT system" >&2
  [ -z "$err" ] || return 1
}

restore()
{

  msg "Restoring $BDIR$MPF to $MPF"
  mount "$DEV1" "$MPF" || error "Cannot mount $MPF"
  insmod "$KOD/ext2.ko"
  mount "$DEV2" "$MPE"

  ls -a "$BDIR$MPF" | grep -v '^.$'|grep -v '^..$'| lcp || error "restore failed!"

  msg "You should now have a FAT partition on $MPF and an EXT2 partition on $MPE"
  echo >&2
  df | grep -e "$MPF" -e "$MPE" >&2
  echo >&2
  echo "Would you like to remove the backup under $BDIR$MPF? y/N" >&2
  yN && rm -rf "$BDIR$MPF"
}

configs_error()
{
  mount -o ro,remount -t yaffs2 /dev/block/mtdblock3 /system
  error "$1"
}

fbackup()
{ # -c file
  [ "$1" = "-c" ] && { cfg=configs_ ; shift ; }

  [ ! -f "$1" ] && return
  if [ -f "$1".orig ] ; then
    echo "WARNING: $1 backup $1.orig already exists!" >&2
    echo >&2
    echo "Do you want to overwrite it? y/N" >&2
    yN || return
    rm "$1".orig
  fi
  cp "$1" "$1".orig || "$cfg"error "Unable to backup $1"
}

configs()
{
  msg "Backing up and Updating $CFGI"
  mount -o rw,remount -t yaffs2 /dev/block/mtdblock3 /system

  fbackup -c "$CFGI"
  cat > "$CFGI" <<EOF || configs_error "Unable to update $CFGI"
 on system
     mount cramfs loop@/system/modules/modules.cramfs /system/modules ro
     mount cramfs loop@/system/xbin/xbin.cramfs /system/xbin ro
     insmod $KOD/ext2.ko
     mknod /dev/mmcblk0p2 b 179 2 1000
     mount ext2 /dev/mmcblk0p2 $MPE noatime nodiratime
EOF

  msg "Backing up and Updating $CFGM"
  fbackup -c "$CFGM"
  cat > "$CFGM" <<EOF  || configs_error "Unable to update $CFGM"
## mountd configuration file

## add a mount entry for each mount point to be managed by mountd
mount {
    ## root block device with partition map or raw FAT file system
    block_device    /dev/block/mmcblk0p1

    ## mount point for block device
    mount_point     /sdcard

    ## true if this mount point can be shared via USB mass storage
    enable_ums      true
}
EOF

  [ ! -d "$MPE" ] && { mkdir "$MPE" || warn "Unable to create EXT2 mount point $MPE" ; }

  mount -o ro,remount -t yaffs2 /dev/block/mtdblock3 /system
}

clearactions()
{
  if [ -z "$CLEARED" ] ; then
    SW_NB='CLEARED'
    SW_NP='CLEARED'
    SW_NM='CLEARED'
    SW_NR='CLEARED'
    SW_NC='CLEARED'
    CLEARED='CLEARED'
  fi
}

VER=1.1
PROG=sdsplit

Usage()
{

  cat >&2 <<EOF

Usage(v$VER):  $PROG [options]

 -h Usage        --help Help

                 -nd|--nodata
 -b|--backup     -nb|--nobackup
 -c|--configs    -nc|--noconfigs
 -p|--partition  -np|--nopartition
 -m|--mkfs       -nm|--nomkfs
 -r|--restore    -nr|--norestore

 -f|--force

 -pm|--pmke2fs   -pe|--pext2    -pb|--pbackup
 -f32|--fat32    -f16|--fat16
 -fs|--fatsize   -es|--ext2size

EOF
}

Help()
{

  cat >&2 <<EOF

Usage(v$VER):  $PROG [options]


'$PROG' will by default perform all of its default actions in sequence. Specifying a
specific action will tell $PROG to only perform that action and skip the others.  You
may instead prefix an action with 'no' to prevent that specific action from being
performed while all the others are run.

PREREQUISITES:

* This is desgined to work with the Jesus Freke updates (tested on JF1.43ADP). Here
is why you need a JF update:  for busybox, so the /init.rc invokes $CFGI, and so the 
ext2.koi and cramfs(?) modules are under $KOD.

* Additionally, you will need a 'mke2fs' executable for android somewhere in your path
(or specify it with --pmke2fs).  One place to get this executable is here:
http://sites.google.com/site/juanjosec/android



ACTIONS:

 --backup|-b       Perform a backup of the $MPF directory to $BDIR$MPF
 --nobackup|-nb    (See --pbackup)

 --config|-c       Configure the system to handle a new ext2 partition on the
 --noconfig|-nc    sdcard.  This involves adding mount options to $CFGI and 
                   to $CFGM along with creating the $MPE mount 
                   point for the ext2 partition on (see --pext2). Backups of the
                   original files will be made (.orig).

 --partition|-p    Wipe the partition table of the sdcard (backup up a printout to
 --nopartition|-np $BAKP) Create two new partitions, first
                   a $FSIZE FAT32 one (see --fatsize) and then a Liunx one (for ext2)
                   on the remainder of the sdcard (see --ext2size).

 --mkfs|-mk        Make the FAT32 (see --fat[16|32]) and EXT2 filesystems (partitioning
 --nomkfs|-nm      only allocates the space for them).  This requires the mke2fs
                   exectuable on the G1/ADP (see --pmke2fs).

 --restore|-r      Restore the original sdcard backup from $BDIR$MPF back to $MPF.
 --norestore|-nr

Along with the above actions there is one additional action if you do not care to
save your original sdcard data:

 --nodata|-nd      Equivalent to: --nobackup --norestore


OPTIONS:

 -h Usage        --help Help

 --force|-f               Force even if the mke2fs executable cannot be found.

 --fatsize|-fs SIZE[KM]   Set the size of the FAT partition in bytes, K or M.
                          (defaults to $FSIZE)
 --ext2size|-es SIZE[KM]  Set the size of the EXT2 partition in bytes, K or M.
                          (default to the remainder)  If you set this, it will not
                          set the FAT parition to the remainder, it will remain
                          $FSIZE unless you explicitly set it to something else.
                          The only reason to use this is if you want to leave space
                          for another partition.

 --fat[16|32}             Make the FAT partition of type 16 or 32.  The default is
                          32 since 16 does not seem to work with my ADP

 --pbackup|-pb PATH       Set the location of the sdcard backup dir
 --pmke2fs|-pm PATH       Set the path to the mke2fs executable (if not already in
                          your PATH)
 --pext2|-pe PATH         Set the mount point for the new ext2 partition (defaults
                          to $MPE)


COPYRIGHT:                Martin Fick <mogulguy@yahoo.com>    GPL2 or above

EOF
}


MPF=/sdcard
MPE=/system/sd
DEV=/dev/block/mmcblk0
DEV1=/dev/block/mmcblk0p1
DEV2=/dev/block/mmcblk0p2

FT=b
FAT=32
FSIZE="500M"
ESIZE=""

MKFS=mke2fs
CFGI=/system/init.rc
CFGM=/system/etc/mountd.conf
UNAME=`uname -r`
KOD="/system/modules/$UNAME/kernel/fs/ext2"
BAKP=/data/local/tmp/partitions.orig
BDIR=/data

while [ $# -gt 0 ] ; do
  case "$1" in

    -h)          Usage ; exit ;;
    --help)      Help  ; exit ;;

    -b|--backup)    clearactions ; SW_NB='' ;;
    -c|--configs)   clearactions ; SW_NC='' ;;
    -p|--partition) clearactions ; SW_NP='' ;;
    -m|--mkfs)      clearactions ; SW_NM='' ;;
    -r|--restore)   clearactions ; SW_NR='' ;;

    -nd|--nodata)      SW_NB="$1" ; SW_NR="$1" ;;

    -nb|--nobackup)    SW_NB="$1" ;;
    -nc|--noconfigs)   SW_NC="$1" ;;
    -np|--nopartition) SW_NP="$1" ;;
    -nm|--nomkfs)      SW_NM="$1" ;;
    -nr|--norestore)   SW_NR="$1" ;;

    -f|--force)        SW_FORCE="$1" ;;

    -pm|--pmke2fs) shift ; MKFS="$1" ;;
    -pe|--pext2)   shift ; MPE="$1" ;;

    -pb|--pbackup)  shift ; BDIR="$1"
          echo "$BDIR" | grep "^$MPF/" > /dev/null &&
            error "backup dir ($BDIR) cannot be a subdirectory of $MPF!"

          [ "$BDIR" = "$MPF" ] && error "cannot backup $MPF to itself!"
          [ -d "$BDIR$MPF" ] && error "backup dir ($BDIR$MPF) already exists!"
        ;;

    -f32|--fat32) FAT=32 ; FT=b ;;
    -f16|--fat16) FAT=16 ; FT=6 ;;

    -fs|--fatsize)  shift ; FSIZE="$1" ;;
    -es|--ext2size) shift ; ESIZE="$1" ;;

    *) Usage ; error "invalid argument $1" ;;
  esac
  shift
done


if [ -z "$SW_NM" ] ; then
  "$MKFS" -h 2> /dev/null
  [ $? -eq 127 -a -z "$SW_FORCE" ] && error "Cannot find $MKFS executable"
fi


[ -z "$SW_NB" ] && backup_sd "$BDIR"

[ -z "$SW_NC" ] && configs

[ -z "$SW_NP" ] && partition

[ -z "$SW_NM" ] && mkfses

[ -z "$SW_NR" ] && restore