#!/bin/bash
#
# Author: Steven Shiau <steven _at_ nchc org tw>
# License: GPL 
# Description:
# This is only for "disk to disk" or "partition to partition" clone.

# it is important to run partimage in save mode with volume=0 so that we
# can send the data to stdout
# This is the basic idea:
# (partimage -z0 -o -d --volume=0 -B gui=no save /dev/hda1 stdout |
#  partimage -M -f3 -b restore /dev/hdc1 stdin)
ocs=$(basename $0)
VOL_ZERO="0"
#create image volumes with a size of X, 
# ignore the MBR by using -M, we will ignore the error caused by devfs style
# in /proc/partitions
DEFAULT_STDOUT_PARTIMAGE_SAVE_OPT="-M -z0 -o -d -b -c -B gui=no --volume=$VOL_ZERO"
DEFAULT_STDIN_PARTIMAGE_RESTORE_OPT="-M -f3 -b"
# port for netcat
NC_PORT_DEFAULT="9000"

# Load DRBL setting and functions
if [ ! -f "/opt/drbl/sbin/drbl-conf-functions" ]; then
  echo "Unable to find /opt/drbl/sbin/drbl-conf-functions! Program terminated!" 
  exit 1
fi
. /opt/drbl/sbin/drbl-conf-functions

# Load some necessary setting from drbl-ocs.conf
. /opt/drbl/conf/drbl-ocs.conf

# Load basic functions of ocs
. /opt/drbl/sbin/ocs-functions

# local functions:
# check if the user input /dev/hda, /dev/hdb...
check_input_param() {
  # return code 3 = disk, return code 5 = partition
  local input_src="$1"
  local recode
  case "$input_src" in
       [hs]d[a-z])
         recode=3
         ;;
       [hs]d[a-z][0-9]*)
         recode=5
         ;;
       *)
        echo "\"$input_src\" $msg_is_unknown_HDdd... $msg_program_stop!"
	echo "$msg_press_enter_to_continue"
        read
        exit 1
  esac
  return $recode
} # end of check_input_param
#
check_pt_then_run_sfdisk() {
  echo "$msg_creating_partition_in_target"
  if [ -f "$pt_tmp" ]; then
    echo "$msg_partition_table_for_target_dev \"$target_hd\":"
    echo "-------------------------------------------------------------"
    [ "$BOOTUP" = "color" ] && $SETCOLOR_WARNING
    cat $pt_tmp
    [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
    echo "-------------------------------------------------------------"
    if [ "$batch_mode" = "yes" ]; then
      fdisk_ans="y"
    else
      [ "$BOOTUP" = "color" ] && $SETCOLOR_WARNING
      echo "$msg_are_u_sure_u_want_to_continue $msg_if_go_on_the_data_will_be_erased_then_confirm"
      [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
      echo -n "[y/N] "
      read fdisk_ans
    fi
    case "$fdisk_ans" in
      [yY]|[yY][eE][sS])
         sfdisk --force $sfdisk_opt /dev/$target_hd < $pt_tmp
         ;;
      *)
         if [ "$partition_table_exist_in_target" = "no" ]; then
           [ "$BOOTUP" = "color" ] && $SETCOLOR_FAILURE
           echo "No partition table exists in /dev/$target_hd, and you choose not to create partition table in /dev/$target_hd! We can not go on without partition table in /dev/$target_hd!!!"
           [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
           echo "$msg_program_stop!"
           exit 1
         fi
         echo "$msg_ok_we_will_keep_old_partition_table"
         ;;
    esac
  else
    [ "$BOOTUP" = "color" ] && $SETCOLOR_FAILURE
    echo "$msg_fail_to_create_partition_table_in_target_dev: /dev/$target_p! $msg_program_stop!!"
    [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
  fi
  echo 'done!'
} # end of check_pt_then_run_sfdisk
#
nc_lp_check() {
  NC_LOCAL_PORT_OPT=
  nc_tmp="$(mktemp /tmp/nc_tmp.XXXXXX)"
  # check if command is nc or netcat
  if which nc &>/dev/null; then
     NC_CMD="nc"
  elif which netcat &>/dev/null; then
     NC_CMD="netcat"
  else
     [ "$BOOTUP" = "color" ] && $SETCOLOR_FAILURE
     echo "Unable to find command netcat or nc!!! Program terminated!"
     [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
     exit 1
  fi

  $NC_CMD -h 2> $nc_tmp
  if [ -n "$(grep -Ei "^[[:space:]]*-p port[[:space:]]+local port number" $nc_tmp)" ]; then
     # This is the version Hobbit wrote (http://www.vulnwatch.org/netcat/)
     # The reason we want to add -q 0 for Hobbit version is that:
     # in Debian, if -q 0 is not set, it will wait forever... nc will not quit.
     # However, in FC3 or ealier version, there is no -q option. nc will quit
     # when EOF.
     [ -n "$(grep "\-q secs" $nc_tmp 2>/dev/null)" ] && NC_QUIT_OPT="-q 0"
     NC_LOCAL_PORT_OPT="$NC_QUIT_OPT -p"
  elif [ -n "$(grep -Ei "^[[:space:]]*-p port[[:space:]]+Specify local port for remote connects" $nc_tmp)" ]; then
     # This is the version Eric Jackson wrote (http://www.monkey.org/~shinobi)
     NC_LOCAL_PORT_OPT=""
  fi
  [ -f "$nc_tmp" ] && rm -f $nc_tmp
  echo "Using \"-l $NC_LOCAL_PORT_OPT port\" when it's netcat listen mode."
} # end of nc_lp_check

#
kill_clone_prog_nc_process() {
  echo "Terminate partimage and $NC_CMD processs if they exist..."
  pkill -u root partimage
  pkill -u root ntfsclone
  pkill -u root dd
  pkill -u root $NC_CMD
} # end of kill_clone_prog_nc_process
#
clone_boot_loader_in_target() {
echo "$msg_delimiter_star_line"
if [ "$CLONE_BOOT_LOADER" != "no" ] && [ "$source_type" = "disk" ] && [ "$mode" = "local" -o "$STATUS" = "clone_client" ]; then
  if [ "$batch_mode" = "yes" ]; then
    mbr_ans="y"
  else
    [ "$BOOTUP" = "color" ] && $SETCOLOR_WARNING
    echo "$msg_do_you_want_to_clone_the_boot_loader_to: $target_p ?"
    [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
    echo -n "[Y/n] "
    read mbr_ans
  fi
  case "$mbr_ans" in
    n|N|[nN][oO])
       echo "OK, $msg_skip_clone_boot_loader."
       ;;
    *)
       if [ "$mode" = "local" ]; then
         echo "Cloning the boot loader from \"$src_hd\" to \"$target_hd\"..."
         # boot loader is the first 446 Bytes, the rest part is partition table.
         dd if=/dev/$source_p of=/dev/$target_p bs=446 count=1 &> /dev/null
         ret=$?
       elif [ "$STATUS" = "clone_client" ]; then
         echo "Cloning the boot loader from that in $SOURCE_IP to \"$target_hd\"..."
         # boot loader is the first 446 Bytes, the rest part is partition table.
         dd if=$hd_tgt_tmp/mbr of=/dev/$target_p bs=446 count=1 &> /dev/null
         ret=$?
       fi
       if [ "$ret" -ge 1 ]; then
         [ "$BOOTUP" = "color" ] && $SETCOLOR_FAILURE
         echo "$msg_failed_to_clone_the_boot_loader: \"$target_hd\"!!!"
         echo "$msg_program_stop!!"
         [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
         exit 1
       fi
       ;;
  esac
fi
} # end of clone_boot_loader_in_target
#
create_partition_table_in_target(){
if [ "$RUN_SFDISK" != "no" ]; then
  echo "$msg_delimiter_star_line"
  if [ "$mode" = "local" -o "$STATUS" = "clone_client" ]; then 
    # try to see if the partition table exists in the target 
    if [ -n "$(LC_ALL=C fdisk -l /dev/$target_hd 2>/dev/null | grep -E "/dev/[sh]d[a-z][0-9]+")" ] ; then
      partition_table_exist_in_target="yes"
      [ "$BOOTUP" = "color" ] && $SETCOLOR_WARNING
      echo "$msg_a_partition_table_already_exist: \"$target_hd\""
      echo "-------------------------------------------------------------"
      LC_ALL=C fdisk -l /dev/$target_hd
      echo "-------------------------------------------------------------"
    else
      partition_table_exist_in_target="no"
    fi
    check_pt_then_run_sfdisk
  fi
fi
} # end of create_partition_table_in_target
#
confirm_do_it_in_target_dev() {
if [ "$mode" = "local" -o "$STATUS" = "clone_client" ]; then
  echo "$msg_delimiter_star_line"
  echo "$msg_target_dev_has_this_partition_table:"
  # try to see if the partition table exists in the target 
  echo "$msg_delimiter_star_line"
  [ "$BOOTUP" = "color" ] && $SETCOLOR_WARNING
  LC_ALL=C fdisk -l /dev/$target_hd
  echo "$msg_delimiter_star_line"
  [ "$BOOTUP" = "color" ] && $SETCOLOR_WARNING
  echo "$msg_uppercase_Warning!!! $msg_uppercase_Warning!!! $msg_uppercase_Warning!!!"
  echo "$msg_uppercase_Warning! $msg_all_data_in_dev_will_be_overwritten: $target_p"
  [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
  if [ "$batch_mode" = "yes" ]; then
    do_ans="y"
  else
    [ "$BOOTUP" = "color" ] && $SETCOLOR_WARNING
    echo "$msg_are_u_sure_u_want_to_continue ?"
    [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
    echo -n "[y/N] "
    read do_ans
  fi
  case "$do_ans" in
    [yY]|[yY][eE][sS])
       echo "$msg_ok_let_do_it"
       ;;
    *)
       exit 1
       ;;
  esac
fi
} # end of confirm_do_it_in_target_dev
#
prepare_local_clone_dev_info() {
  local_tmp="$(mktemp -d /tmp/ocs_onthefly_local.XXXXXX)"
  # since it's local, target tmp dir is the same one with local_tmp
  hd_tgt_tmp="$local_tmp"
  pt_tmp="$hd_tgt_tmp/pt.sf"
  pt_info="$hd_tgt_tmp/partition.info"

  sfdisk -d /dev/$src_hd > $pt_tmp
  # output the filesystem of partition to be refered by client. Ex:
  # /dev/hda1 reiserfs
  # /dev/hda2 ext3
  for part in `grep -i "Id=" $pt_tmp | cut -d" " -f1`; do
    echo "Collecting partition $part info..."
    filesystem="$(get_part_info $part filesystem)"
    pt_size="$(get_part_info $part size)"
    echo "$part $filesystem $pt_size" >> $pt_info
  done
  # SWAP partition info, maybe more than 1
  for partition in `cat $pt_tmp | grep "Id=82" | cut -d" " -f1 | sed -e 's/\/dev\///g'`
  do
    echo "Outputing swap UUID/LABEL..."
    # change the target swap partition, like hda2 -> hdb2
    target_swap_part_info="$(echo swappt-${partition}.info | sed -e "s|[hs]d[a-z]|$target_hd|g")"
    output_swap_partition_uuid_label /dev/$partition $local_tmp/$target_swap_part_info
  done
  # change the dev to target in the $pt_tmp and $pt_info
  LC_ALL=C perl -p -i -e "s|/dev/[hs]d[a-z]|/dev/$target_hd|g" $pt_tmp
  LC_ALL=C perl -p -i -e "s|/dev/[hs]d[a-z]|/dev/$target_hd|g" $pt_info
  ret_pt_sf=$?
  # pack all the info files
  ( 
    cd $local_tmp/
    tar czf ocs-onthefly-info.tgz *
  )
} # end of prepare_local_clone_dev_info
#
prepare_network_clone_dev_info() {
  if [ "$STATUS" = "clone_server" ]; then
    pt_tmp=$hd_src_tmp/pt.sf
    pt_info="$hd_src_tmp/partition.info"
    # partition table
    sfdisk -d /dev/$src_hd > $pt_tmp
    # The output of CHS is ${src_hd}-chs.sf
    output_HD_CHS $src_hd $hd_src_tmp/
    mv -f $hd_src_tmp/${src_hd}-chs.sf $hd_src_tmp/chs.sf
    # MBR
    dd if=/dev/$source_p of=$hd_src_tmp/mbr count=1 bs=512 &> /dev/null
    # output the filesystem of partition to be refered by client. Ex:
    # /dev/hda1 reiserfs
    # /dev/hda2 ext3
    for part in `grep -i "Id=" $pt_tmp | cut -d" " -f1`; do
      echo "Collecting partition $part info..."
      filesystem="$(get_part_info $part filesystem)"
      pt_size="$(get_part_info $part size)"
      echo "$part $filesystem $size" >> $hd_src_tmp/partition.info
    done
    # SWAP partition info, maybe more than 1
    for partition in `cat $pt_tmp | grep "Id=82" | cut -d" " -f1 | sed -e 's/\/dev\///g'`
    do
      echo "Outputing swap UUID/LABEL..."
      output_swap_partition_uuid_label /dev/$partition $hd_src_tmp/swappt-${partition}.info
    done
    # pack all the info files
    ( 
      cd $hd_src_tmp/
      tar czf ocs-onthefly-info.tgz *
    )
    # wait for client to download it
    cat $hd_src_tmp/ocs-onthefly-info.tgz | $NC_CMD -l $NC_LOCAL_PORT_OPT $NC_PORT &
    NC_PORT=$((NC_PORT + 2))
  elif [ "$STATUS" = "clone_client" ]; then
    # Get the pt and mbr... from server
    $NC_CMD $SOURCE_IP $NC_PORT > $hd_tgt_tmp/ocs-onthefly-info.tgz
    NC_PORT=$((NC_PORT + 2))
    if [ ! -f "$hd_tgt_tmp/ocs-onthefly-info.tgz" ]; then
      [ "$BOOTUP" = "color" ] && $SETCOLOR_FAILURE
      echo "The partition table, MBR infomation is not received from another machine (IP address $SOURCE_IP)!"
      echo "$msg_program_stop"
      [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
      exit 1
    fi
    ( 
      cd $hd_tgt_tmp/
      tar xzf ocs-onthefly-info.tgz
    )
    # partition table and info
    pt_tmp="$hd_tgt_tmp/pt.sf"
    pt_info="$hd_tgt_tmp/partition.info"
    # change the dev to target in the $pt_tmp nd $pt_info
    LC_ALL=C perl -p -i -e "s|/dev/[hs]d[a-z]|/dev/$target_hd|g" $pt_tmp
    LC_ALL=C perl -p -i -e "s|/dev/[hs]d[a-z]|/dev/$target_hd|g" $pt_info
    # FIXME! get sfdisk_opt if load_HD_CHS is yes
    [ "$load_HD_CHS" = "yes" ] && load_HD_geometry $hd_tgt_tmp/
  fi
} # end of prepare_network_clone_dev_info
#
local_partition_to_partiton_clone() {
  local pt_fs="$1"
  local src_p="$2"  # src_p is like /dev/hda1
  local tgt_p="$3"  # tgt_p is like /dev/hdb1
  local pt_size ret
  echo "Cloning the $src_p to $tgt_p..."
  checkInodeForDevice $tgt_p
  echo "$msg_delimiter_star_line"
  if [ "$pt_fs" = "ntfs" ]; then
    echo "Using ntfsclone to clone..."  
    check_ntfs_partition_integrity $src_p
    ntfsclone --save-image --output - $src_p 2>/dev/null | \
    ntfsclone --restore-image --overwrite $tgt_p -
    ret=$?
  elif `is_partimage_support_fs $pt_fs`; then
    echo "Using partimage to clone..."  
    partimage $DEFAULT_STDOUT_PARTIMAGE_SAVE_OPT save $src_p stdout 2> /dev/null | \
    partimage $DEFAULT_STDIN_PARTIMAGE_RESTORE_OPT $PARTIMAGE_RESTORE_EXTRA_OPT restore $tgt_p stdin
    ret=$?
  else
    echo "Filesystem in $src_p is not well supported. Use dd to clone..."  
    pt_size="$(get_part_info $src_p size)"
    trigger_dd_status_report $src_p $pt_size &
    LC_ALL=C dd bs=1M if=$src_p of=$tgt_p
    ret=$?
  fi
  if [ "$ret" -ge 1 ]; then
     echo "Failed to clone $src_p to $tgt_p!!!"
     echo "$msg_program_stop!!"
     exit 1
  fi
} # end of local_partition_to_partiton_clone
#
local_dev_clone() {
  case "$source_type" in
    partition)
       part_fs="$(grep -Ew "/dev/$target_p" $pt_info | awk -F" " '{print $2}')"
       local_partition_to_partiton_clone $part_fs /dev/$source_p /dev/$target_p
       ;;
    disk)
       for target_part in `get_known_partition $pt_tmp`; do
         # we need to know the source partition, so replace it, ex. hdc1 -> hda1
         # Ex: target_part: hdc1, hddev: hdc, part_no: 1, src_part: hda1
         hddev=${target_part:0:3}
         part_no=${target_part:3}
         src_part=$( echo $target_part | sed -e "s/$hddev/$src_hd/g" )
         part_fs="$(grep -Ew "/dev/$target_part" $pt_info | awk -F" " '{print $2}')"
         local_partition_to_partiton_clone $part_fs /dev/$src_part /dev/$target_part
       done
       ;;
  esac
} # end of local_dev_clone
#
feed_partition_in_server() {
  local pt_fs="$1"
  local src_p="$2"  # src_p is like /dev/hda1
  local ret
  echo "Feeding partition $src_p in listen mode with port $NC_PORT..."
  echo "$msg_delimiter_star_line"
  if [ "$pt_fs" = "ntfs" ]; then
    echo "Using ntfsclone to clone..."  
    check_ntfs_partition_integrity $src_p
    ntfsclone --save-image --output - $src_p 2>/dev/null | \
    $filter_comp | $NC_CMD -l $NC_LOCAL_PORT_OPT $NC_PORT &
    ret=$?
  elif `is_partimage_support_fs $pt_fs`; then
    echo "Using partimage to clone..."  
    partimage $DEFAULT_STDOUT_PARTIMAGE_SAVE_OPT save $src_p stdout 2> /dev/null | \
    $filter_comp | $NC_CMD -l $NC_LOCAL_PORT_OPT $NC_PORT &
    ret=$?
  else
    echo "Filesystem in $src_p is not well supported. Use dd to clone..."  
    LC_ALL=C dd bs=1M if=$src_p | \
    $filter_comp | $NC_CMD -l $NC_LOCAL_PORT_OPT $NC_PORT &
    ret=$?
  fi
  if [ "$ret" -ge 1 ]; then
     echo "Failed to feeding partition $src_p in this server!!!"
     echo "$msg_program_stop!!"
     exit 1
  fi
} # end of feed_partition_in_server
#
receive_partition_from_server_then_write() {
  local	pt_fs="$1"
  local tgt_p="$2"  # tgt_p is like /dev/hda1
  local ret pt_size
  echo "Restoring $tgt_p from $SOURCE_IP:$NC_PORT..."
  checkInodeForDevice $tgt_p
  echo "$msg_delimiter_star_line"
  if [ "$pt_fs" = "ntfs" ]; then
    echo "Using ntfsclone to clone..."  
    $NC_CMD $SOURCE_IP $NC_PORT | $filter_decomp | \
    ntfsclone --restore-image --overwrite $tgt_p -
    ret=$?
  elif `is_partimage_support_fs $pt_fs`; then
    echo "Using partimage to clone..."  
    $NC_CMD $SOURCE_IP $NC_PORT | $filter_decomp | \
    partimage $DEFAULT_STDIN_PARTIMAGE_RESTORE_OPT $PARTIMAGE_RESTORE_EXTRA_OPT restore $tgt_p stdin
    ret=$?
  else
    echo "Filesystem in $src_p is not well supported. Use dd to clone..."  
    pt_size="$(grep -Ew "$tgt_p" $pt_info | awk -F" " '{print $3}')"
    trigger_dd_status_report $tgt_p $pt_size &
    $NC_CMD $SOURCE_IP $NC_PORT | $filter_decomp | \
    LC_ALL=C dd bs=1M of=$tgt_p
    ret=$?
  fi
  if [ "$ret" -ge 1 ]; then
     echo "Failed to clone remote image to $tgt_p!!!"
     echo "$msg_program_stop!!"
     exit 1
  fi
} # end of receive_partition_from_server_then_write
#
clone_over_net() {
  # try to get the client's type
  case "$source_type" in
    partition)
       if [ "$STATUS" = "clone_server" ]; then
         echo "Running the clone server for $source_p in port $NC_PORT..."
         part_fs="$(grep -Ew "/dev/$source_p" $pt_info | awk -F" " '{print $2}')"
	 feed_partition_in_server $part_fs /dev/$source_p
       elif [ "$STATUS" = "clone_client" ]; then
         echo "Restoring $target_p from $SOURCE_IP:$NC_PORT..."
         part_fs="$(grep -Ew "/dev/$target_p" $pt_info | awk -F" " '{print $2}')"
	 receive_partition_from_server_then_write $part_fs /dev/$target_p
       fi
       ;;
    disk)
       for target_part in `get_known_partition $pt_tmp`; do
         # we need to know the source partition, so replace it, ex. hdc1 -> hda1
         # Ex: target_part: hdc1, hddev: hdc, part_no: 1, src_part: hda1
         hddev=${target_part:0:3}
         part_no=${target_part:3}
         src_part=$( echo $target_part | sed -e "s/$hddev/$src_hd/g" )
         if [ "$STATUS" = "clone_server" ]; then
           part_fs="$(grep -Ew "/dev/$src_part" $pt_info | awk -F" " '{print $2}')"
	   feed_partition_in_server $part_fs /dev/$src_part
         elif [ "$STATUS" = "clone_client" ]; then
           part_fs="$(grep -Ew "/dev/$target_part" $pt_info | awk -F" " '{print $2}')"
	   receive_partition_from_server_then_write $part_fs /dev/$target_part
         fi
	 # use the next port to avoid being occupied.
	 NC_PORT=$((NC_PORT + 2))
       done
       ;;
  esac
  echo "$msg_delimiter_star_line"
  [ -n "$filter" ] && filter_opt="-i $filter"
  if [ "$STATUS" = "clone_server" ]; then
    [ "$BOOTUP" = "color" ] && $SETCOLOR_WARNING
    echo "$msg_now_run_this_cmd_in_target_machine:"
    echo "$DRBL_SCRIPT_PATH/sbin/$ocs $filter_opt -g auto --source-IP $my_ips -t [TARGET_DEV] (TARGET_DEV is like hda, hdb, hda1, hdb1... If you do not want to re-install grub again, remove the '-g auto' in the command)"
    [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
  fi
} # end of clone_over_net
#
create_swap_part_in_target_dev() {
# create swap partition, clean the temp partition table, and re-install grub
if [ "$mode" = "local" -o "$STATUS" = "clone_client" ]; then
  echo "$msg_delimiter_star_line"
  #
  if [ "$resize_partition" = "on" ]; then
    for target_part in `get_known_partition $pt_tmp`; do
      # hda1 -> hd_tmp, part_no_tmp ,i.e => hda, 1 
      hd_tmp="${target_part:0:3}"
      part_no_tmp="${target_part:3}"
      echo "Now resize the partition for $hd_tmp$part_no_tmp"
      $DRBL_SCRIPT_PATH/sbin/resize_part $hd_tmp $part_no_tmp
      echo $msg_delimiter_star_line
    done
  fi
  #
  echo "Creating the swap partition if exists..."
  # swap partition
  for partition in `cat $pt_tmp | grep "Id=82" | cut -d" " -f1 | sed -e 's/\/dev\///g'`
  do
    echo "Found the swap partition /dev/$partition, create it by:"
    # read LABEL, UUID info for $partition if swappt-$partition.info exists
    uuid_opt=""
    label_opt=""
    if [ -e "$hd_tgt_tmp/swappt-$partition.info" ]; then
      UUID=""
      LABEL=""
      . "$hd_tgt_tmp/swappt-$partition.info"
      [ -n "$UUID" ] && uuid_opt="-U $UUID"
      [ -n "$LABEL" ] && label_opt="-L $LABEL"
    fi
    echo "mkswap-uuid $label_opt $uuid_opt /dev/$partition"
    mkswap-uuid $label_opt $uuid_opt /dev/$partition
  done
  echo "$msg_delimiter_star_line"
  # clean the tmp file
  [ -f "$pt_tmp" ] && rm -f $pt_tmp
  [ "$install_grub" = "on" ] && install_grub_hd $grub_partition
  echo "$msg_delimiter_star_line"
fi
} # end of create_swap_part_in_target_dev
#
set_filter_program() {
case "$filter" in
  gzip|gz)
       if which gzip &>/dev/null; then
         filter_comp="gzip -c"
         filter_decomp="gzip -cd"
       else
         [ "$BOOTUP" = "color" ] && $SETCOLOR_FAILURE
         echo "gzip is NOT found! Program terminated!!!"
         [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
	 exit 1
       fi
       ;;
  bzip|bzip2)
       if which bzip2 &>/dev/null; then
         filter_comp="bzip2 -c"
         filter_decomp="bzip2 -cd"
       else
         [ "$BOOTUP" = "color" ] && $SETCOLOR_FAILURE
         echo "bzip2 is NOT found! Program terminated!!!"
         [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
	 exit 1
       fi
       ;;
   cat)
       filter_comp="cat"
       filter_decomp="cat"
       ;;
   *)
       if which lzop &>/dev/null; then
         filter_comp="lzop -c"
         filter_decomp="lzop -cd"
       else
         [ "$BOOTUP" = "color" ] && $SETCOLOR_FAILURE
         echo "lzop is NOT found! Program terminated!!!"
         [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
	 exit 1
       fi
       ;;
esac
} # end of set_filter_program
#
pre_checking() {
# check if it runs in DRBL server and it's not DRBL/Clonezilla live, if yes, warn user!
if [ -d "$pxecfg_pd" -a ! -d "/live_media" ]; then
  [ "$BOOTUP" = "color" ] && $SETCOLOR_WARNING
  echo "$msg_Warning!!! $msg_should_not_run_ocs_onthefly_in_server"
  echo "$msg_are_u_sure_u_want_to_continue ?"
  [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
  echo "[y/N]"
  read clone_ans
  case "$clone_ans" in
	  [y|Y][eE][sS])
          [ "$BOOTUP" = "color" ] && $SETCOLOR_FAILURE
	  echo "$msg_really_dangerous_then_continue"
          [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
	  echo "$msg_press_enter_to_continue"
	  read
	  ;;
	  *)
	  exit 0
	  ;;
  esac
fi

# check grub_partition if we want to install grub
if [ "$install_grub" = "on" ]; then
  if [ -z "`echo $grub_partition | grep "/dev/[sh]d[a-z][1-9]*"`" -a "$grub_partition" != "auto" ]; then
    [ "$BOOTUP" = "color" ] && $SETCOLOR_FAILURE
    echo "\"$grub_partition\" $msg_is_not_valid_grub_root! $msg_program_stop!"
    [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
    exit 1
  fi
fi

#
if [ "$mode" = "local" ]; then
  # check if source and target are the same one if it's local clone!!!
  # we do not accept hda -> hda or hda2 -> hda2, however, hda2 -> hda3 is ok.
  if echo $target_p | grep -q $source_p; then
    echo "$msg_src_target_r_same_dev $msg_program_stop"
    exit 1
  fi
fi
} # end of pre_checking

#
USAGE() {
    echo "Usage:"
    echo "To run clonezilla on-the-fly:"
    echo "$ocs [OPTION]"
    echo "Option"
    echo "-b, --batch-mode   Run clone in batch mode (DANGEROUS!)"
    echo "-e, --resize-partition   resize the target disk in target machine (To solve the small partition image restored to larger partition problem.)"
    echo "-f, --source DEV         specify the source device as DEV (hda, hda1...)"
    echo "-g, --grub-install GRUB_PARTITION     install grub in hda with root grub directory in GRUB_PARTITION when restoration finishs, GRUB_PARTITION can be one of \"/dev/hda1\", \"/dev/hda2\"... or \"auto\" (\"auto\" will clonezilla detects the grub root partition automatically)"
    echo "-i, --filter PROGRAM     use the PROGRAM (gzip/lzop/bzip2/cat) before sending partition data to netcat (only in network clone mode). The default action is lzop. Use \"cat\" if you do not want to compress (Good for fast internode network)."
    echo "-n, --no-sfdisk          skip partition table creation"
    echo "-m, --no-boot-loader-clone  do NOT clone boot loader"
    echo "-o, --load-geometry      force to use the saved CHS (cylinders, heads, sectors) when using sfdisk in restoring."
    echo "-p, --port PORT          specify the netcat port (Only in network clone mode)"
    echo "-r, --server             specify the running machine is in network clone server."
    echo "-s, --source-IP IP       specify the source IP address (used in target client machine)."
    echo "-t, --target DEV         specify the target device as DEV (hda, hda1...)"
    echo "-v, --verbose            prints verbose information"
    echo "Ex:"
    echo "1. To clone local hda to local hdb, run"
    echo "   $ocs -f hda -t hdb"
    echo "2. To clone hda (in machine A with IP 192.168.100.1) to hda (in machine B) via network,"
    echo "   In machine A, boot it into DRBL client mode, then run"
    echo "   $ocs -r -f hda"
    echo "   Then in machine B, boot it into DRBL client mode, too. Then run"
    echo "   $ocs --source-IP 192.168.100.1 -t hda"
    echo
}

########################
##### MAIN PROGRAM #####
########################
# Fedora Core 1 seems to use dumb for rc1, we have to force it use linux.
# otherwise setterm will complain.
[ -z "$TERM" -o "$TERM" = "dumb" ] && TERM="linux"
echo "Setting the TERM as $TERM"
export TERM="$TERM"

#
check_if_root

# PARTIMAGE_RESTORE_OPT & PARTIMAGE_SAVE_OPT will put into partimage command options
PARTIMAGE_RESTORE_OPT=
PARTIMAGE_SAVE_OPT=
STATUS=
load_HD_CHS=
batch_mode="no"

# Parse command-line options
while [ $# -gt 0 ]; do
  case "$1" in
    -b|--batch-mode)
            shift; batch_mode="yes"
	    ;;
    -l|--language)
	shift;
        if [ -z "$(echo $1 |grep ^-.)" ]; then
          # skip the -xx option, in case 
	  specified_lang="$1"
	  shift
        fi
	;;
    -g|--grub-install)  
            install_grub="on"
            shift
            if [ -z "$(echo $1 |grep ^-.)" ]; then
              # skip the -xx option, in case 
              grub_partition=$1
              shift
            fi
            ;;
    -n|--no-sfdisk)
            shift; RUN_SFDISK="no"
	    ;;
    -m|--no-boot-loader-clone)
            shift; CLONE_BOOT_LOADER="no"
	    ;;
    -s|--source-IP)
            shift;
	    STATUS="clone_client"
            if [ -z "$(echo $1 |grep ^-.)" ]; then
              # skip the -xx option, in case 
              SOURCE_IP=$1
            fi
            shift;;
    -f|--source)
            shift;
            if [ -z "$(echo $1 |grep ^-.)" ]; then
              # skip the -xx option, in case 
              source_p=$1
            fi
            shift;;
    -t|--target)
            shift;
            if [ -z "$(echo $1 |grep ^-.)" ]; then
              # skip the -xx option, in case 
              target_p=$1
            fi
            shift;;
    -p|--port)
            shift;
            if [ -z "$(echo $1 |grep ^-.)" ]; then
              # skip the -xx option, in case 
              NC_PORT=$1
            fi
            shift;;
    -i|--filter)
            shift;
            if [ -z "$(echo $1 |grep ^-.)" ]; then
              # skip the -xx option, in case 
	      filter=$1
            fi
            shift;;
    -r|--server)
            shift; STATUS="clone_server"
            ;;
    -e|--resize-partition)
            resize_partition="on"
	    shift;;
    -o|--load-geometry)
	    load_HD_CHS="yes"
            shift;;
    -nogui|--nogui)
            # -nogui is for backward compatable, better to use --nogui
            nogui="on"
            shift;;
    -v|--verbose)
	    shift; verbose="on"
            ;;
    -*)     echo "${0}: ${1}: invalid option" >&2
            USAGE >& 2
            exit 2 ;;
    *)      break ;;
  esac
done

#
if [ "$nogui" = "on" ]; then
  PARTIMAGE_RESTORE_EXTRA_OPT="-B gui=no"
fi
#
if [ -n "$STATUS" ]; then
  # It's in network clone mode
  if [ "$STATUS" = "clone_server" ]; then
    [ -z "$source_p" ] && USAGE && exit 1
  elif [ "$STATUS" = "clone_client" ]; then
    [ -z "$target_p" -o -z "$SOURCE_IP" ] && USAGE && exit 1
  fi
  #
  ask_and_load_lang_set $specified_lang
  echo "$msg_delimiter_star_line"
  mode="network"
  my_ips="$(/opt/drbl/bin/get-all-nic-ip -r)"
  echo "$msg_my_IP_in_drbl_env: $my_ips"
  [ -z "$NC_PORT" ] && NC_PORT=$NC_PORT_DEFAULT
  # The NC port for target machine to notify the server
  JOB_NOTIFY_PORT=$((NC_PORT +1))
  # Get the source port option of nc is "-p" or none.
  nc_lp_check
else
  # It's in local clone mode
  [ -z "$source_p" -o -z "$target_p" ] && USAGE && exit 1
  #
  ask_and_load_lang_set $specified_lang
  echo "$msg_delimiter_star_line"
  mode="local"
fi

if [ "$verbose" = "on" ]; then
  echo "PARTIMAGE_RESTORE_OPT: $PARTIMAGE_RESTORE_OPT"
  echo "PARTIMAGE_SAVE_OPT: $PARTIMAGE_SAVE_OPT"
  echo "SOURCE: $source_p"
  echo "TARGET: $target_p"
  echo "PORT for netcat: $NC_PORT"
fi

#
set_filter_program

pre_checking

# check source and target type
if [ -n "$source_p" ]; then
  check_input_param $source_p
  ret=$?
  case "$ret" in
     3)
  	source_type="disk"
  	;;
     5)
  	source_type="partition"
  	;;
  esac
fi
if [ -n "$target_p" ]; then
  check_input_param $target_p
  ret=$?
  case "$ret" in
     3)
  	target_type="disk"
  	;;
     5)
  	target_type="partition"
  	;;
  esac
fi

case "$mode" in
  local)
    if [ "$source_type" != "$target_type" ]; then
      [ "$BOOTUP" = "color" ] && $SETCOLOR_FAILURE
      echo "$msg_different_type_of_input_devs ($source_p to $target_p)! $msg_program_stop!"
      [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
      exit 1
    fi
    ;;
  network)
    # clean the stalled partimage and netcat process
    kill_clone_prog_nc_process
    ;;
esac


#
if [ "$STATUS" = "clone_server" ]; then
  hd_src_tmp="$(mktemp -d /tmp/ocs_onthefly_src.XXXXXX)"
  [ "$BOOTUP" = "color" ] && $SETCOLOR_WARNING
  echo "$msg_this_is_for_source_machine."
  [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
  echo "source_type=$source_type" > $hd_src_tmp/target_type.ocs_onthefly
  cat $hd_src_tmp/target_type.ocs_onthefly | $NC_CMD -l $NC_LOCAL_PORT_OPT $NC_PORT &
  NC_PORT=$((NC_PORT + 2))
elif [ "$STATUS" = "clone_client" ]; then
  hd_tgt_tmp="$(mktemp -d /tmp/ocs_onthefly_tgt.XXXXXX)"
  [ "$BOOTUP" = "color" ] && $SETCOLOR_WARNING
  echo "$msg_this_is_for_target_machine"
  [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
  $NC_CMD $SOURCE_IP $NC_PORT > $hd_tgt_tmp/target_type.ocs_onthefly
  NC_PORT=$((NC_PORT + 2))
  . $hd_tgt_tmp/target_type.ocs_onthefly
  source_type=$source_type
fi

# create the partitions if necessary.
[ -n "$source_p" ] && src_hd=$(echo $source_p | sed -e "s/[0-9]*//g")
[ -n "$target_p" ] && target_hd=$(echo $target_p | sed -e "s/[0-9]*//g")

echo "$msg_delimiter_star_line"
# turn on DMA and turn off swap/LVM.
screen_not_blank
[ -n "$target_p" ] && turn_on_hd_dma /dev/$target_hd

# swapoff -a, just in case
if [ -e /etc/debian_version -o -e /etc/SuSE-release ]; then
  # Debian
  # just stop it!
  [ -e /etc/init.d/mkswapfile ] && /etc/init.d/mkswapfile stop
else
  # RH-like
  [ -f /var/lock/subsys/mkswapfile ] && /etc/init.d/mkswapfile stop
fi
/sbin/swapoff -a
# Stop LVM so that the HD will not be occupied, we use script comes from
# gentoo, but actually just run "vgchange -an" will be ok.
$DRBL_SCRIPT_PATH/sbin/lvm2-stop.sh
echo "$msg_delimiter_star_line"

# prepare the partition table and MBR (if necessary)
case "$mode" in
  local)   prepare_local_clone_dev_info ;;
  network) prepare_network_clone_dev_info ;;
esac

# confirm first
confirm_do_it_in_target_dev

# partition table
create_partition_table_in_target

# process the boot loader
clone_boot_loader_in_target

#
echo "$msg_delimiter_star_line"
# start cloning
case "$mode" in
  local) local_dev_clone ;;
  network) clone_over_net ;;
esac

#
create_swap_part_in_target_dev

if [ "$STATUS" = "clone_server" ]; then
  echo "$msg_delimiter_star_line"
  echo -n "Waiting for the target machine to connect... "
  $NC_CMD -l $NC_LOCAL_PORT_OPT $JOB_NOTIFY_PORT
  [ -d "$hd_src_tmp" ] && rm -rf $hd_src_tmp
elif [ "$STATUS" = "clone_client" ]; then
  echo "$msg_delimiter_star_line"
  echo -n "Notifying the source machine that my job is done... "
  echo 'done!' | $NC_CMD $NC_QUIT_OPT $SOURCE_IP $JOB_NOTIFY_PORT
  [ -d "$hd_tgt_tmp" ] && rm -rf $hd_tgt_tmp
  echo 'done!'
fi

exit 0
