home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / boot / i386 / rescue / bin / dd_rhelp < prev    next >
Text File  |  2006-11-29  |  31KB  |  1,242 lines
  1. #!/bin/sh
  2. # Begin dd_rhelp
  3. # Copyright (C) 2004 LAB Valentin <vaab@free.fr>
  4. #  
  5. # This program is free software; you can redistribute it and/or modify
  6. # it under the terms of the GNU General Public License as published by
  7. # the Free Software Foundation; either version 2 of the License, or
  8. # (at your option) any later version.
  9. #  
  10. # This program is distributed in the hope that it will be useful,
  11. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. # GNU General Public License for more details.
  14. #  
  15. # You should have received a copy of the GNU General Public License
  16. # along with this program; if not, write to the Free Software
  17. # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18. #  
  19. # TODO : 
  20. # 
  21. # 
  22. #   x Add a feature that if a log file is not found and the dest file has data throws an error or a warning... or something
  23. # 
  24. #   x - close parts should be joined by testing gaps between them...
  25. #   x - BUG : show_bar doesn't correctly draw end of bar when a correct EOF is
  26. #  found. (done ?)
  27. #   x - found which is the correct EOF in log. (done ?)
  28. #   x - Tests and ensures that nb_err is greater than 1.
  29. #   x - First time it is launched, checks right and left limits of chunks.
  30. #   x - Make a estimation time of end. Worse and good.
  31. #   x - Test if dd_rescue is the good version : the one that makes a summary 
  32. #  even in maxerr mode (partly done...)
  33. #   x - less but clearer output if possible (ansi color ?)
  34. #   x - Real handling of options... for max_err min_bs max_bs, the log_file 
  35. #  source... etc ...
  36. #   x - Much cleaner code.
  37. #   x - Better internal Map, with dd_rescued byte, error bytes, clean bytes...
  38. #
  39. # === Do not touch these vars, they are compiled at 'configure' time.
  40. #
  41.  
  42.  
  43. # THIS CODE IS OBSOLETE : PROGRAMS PATHS ARE COMPUTED AT RUNTIME.
  44. # ---
  45. # Where to find programs
  46.  
  47. #SED="@SED@"
  48. #GREP="@GREP@"
  49. #CAT="@CAT@"
  50. #CUT="@CUT@"
  51. #TR="@TR@"
  52. #HEAD="@HEAD@"
  53. #TAIL="@TAIL@"
  54. #TOUCH="@TOUCH@"
  55. #WC="@WC@"
  56. #BC="@BC@"
  57. # ---
  58.  
  59.  
  60. # Some info
  61.  
  62. email="vaab@free.fr"
  63. version="0.0.6"
  64. state="beta"
  65. author="LAB Valentin"
  66.  
  67. # Including 'libcolor.sh'
  68.  
  69. # If COLUMNS hasn't been set yet (bash sets it but not when called as
  70. # sh), do it ourself
  71.  
  72. if [ -z "$COLUMNS" ]
  73. then
  74.     # Get the console device if we don't have it already
  75.     # This is ok by the FHS as there is a fallback if
  76.     # /usr/bin/tty isn't available, for example at bootup.
  77.  
  78.     test -x /usr/bin/tty && CONSOLE=`/usr/bin/tty`
  79.     test -z "$CONSOLE" && CONSOLE=/dev/console
  80.  
  81.     # Get the console size (rows columns)
  82.  
  83.     stty size > /dev/null 2>&1
  84.     if [ "$?" == 0 ]
  85.     then
  86.     [ "$CONSOLE" == "/dev/console" ] && SIZE=$(stty size < $CONSOLE) \
  87.                                          || SIZE=$(stty size)
  88.  
  89.         # Strip off the rows leaving the columns
  90.  
  91.         COLUMNS=${SIZE#*\ }
  92.     else
  93.     COLUMNS=80
  94.     fi
  95.  
  96. fi
  97.  
  98. COL=$[$COLUMNS - 10]
  99. WCOL=$[$COLUMNS - 30]
  100. SCOL=$[$COLUMNS - 4]
  101. LCOL=$[$COLUMNS - 1]
  102.  
  103.  
  104.  
  105. SET_COL=$(echo -en "\\033[${COL}G")
  106. SET_SCOL=$(echo -en "\\033[${SCOL}G")
  107. SET_WCOL=$(echo -en "\\033[${WCOL}G")
  108. SET_LCOL=$(echo -en "\\033[${LCOL}G")
  109.  
  110. SET_BEGINCOL=$(echo -en "\\033[0G")
  111.  
  112.  
  113.  
  114. NORMAL=$(echo -en "\\033[0;37m")
  115. RED=$(echo -en "\\033[1;31m")
  116. GREEN=$(echo -en "\\033[1;32m")
  117. YELLOW=$(echo -en "\\033[1;33m")
  118. BLUE=$(echo -en "\\033[1;34m")
  119. GRAY=$(echo -en "\\033[1;30m")
  120. WHITE=$(echo -en "\\033[1;37m")
  121.  
  122. SUCCESS=$GREEN
  123. WARNING=$YELLOW
  124. FAILURE=$RED
  125. NOOP=$BLUE
  126. ON=$SUCCESS
  127. OFF=$FAILURE
  128. ERROR=$FAILURE
  129.  
  130. # Including 'libcommon.sh'
  131.  
  132. # DEPEND on libcolor
  133.  
  134. [ -n "$exname" ] || exname=$(basename $0)
  135.  
  136. function print_exit()
  137. {
  138.     echo $@;
  139.     exit 1;
  140. };
  141.  
  142. function print_syntax_error()
  143. {
  144.     [ "$*" ] ||    print_syntax_error "$FUNCNAME: no arguments"
  145.     print_exit "${ERROR}script error:${NORMAL} $@";
  146. };
  147.  
  148. function print_syntax_warning()
  149. {
  150.     [ "$*" ] || print_syntax_error "$FUNCNAME: no arguments.";
  151.     [ "$exname" ] || print_syntax_error "$FUNCNAME: 'exname' var is null or not defined.";
  152.     echo "$exname: ${WARNING}script warning:${NORMAL} $@";
  153. };
  154.  
  155. function print_error()
  156. {
  157.     [ "$*" ] || print_syntax_warning "$FUNCNAME: no arguments.";
  158.     [ "$exname" ] || print_exit "$FUNCNAME: 'exname' var is null or not defined.";
  159.     print_exit "$exname: ${ERROR}error:${NORMAL} $@"
  160. };
  161.  
  162. function print_warning()
  163. {
  164.     [ "$*" ] || print_syntax_warning "$FUNCNAME: no arguments.";
  165.     [ "$exname" ] || print_syntax_error "$FUNCNAME: 'exname' var is null or not defined.";
  166.     echo "$exname: ${WARNING}warning:${WARNING} $@"
  167. };
  168.  
  169. function print_usage()
  170. {
  171.     [ "$usage" ] || print_error "$FUNCNAME: 'usage' variable is not set or empty."
  172.     echo "usage: $usage"
  173.  
  174. #    if [ "$_options" != "" ]
  175. #    then    
  176.     
  177.  
  178. #    fi
  179. }
  180.  
  181. function invert_list()
  182. {
  183.     newlist=" "
  184.     for i in $*
  185.     do
  186.       newlist=" $i${newlist}"
  187.     done
  188.     echo $newlist;
  189. };
  190.  
  191. function depends()
  192. {
  193.     for i in $@
  194.     do
  195.     if ! type $i > /dev/null 2>&1
  196.     then
  197.        print_error "dependency check : couldn't find '$i' command."
  198.     fi
  199.     done
  200. }
  201.  
  202. function require()
  203. {
  204.     for i in $@
  205.     do
  206.     if ! type $i > /dev/null 2>&1
  207.     then
  208.        return 1;
  209.     fi
  210.     done
  211. }
  212.  
  213. function print_octets ()
  214. {
  215.     [ "$*" ] || print_syntax_error "$FUNCNAME: no arguments.";
  216.     [ "$2" ] && print_syntax_error "$FUNCNAME: too much arguments.";
  217.  
  218.     [ "$( echo "$1 < 1024" | bc )" == "1" ] && { echo -n "$1 octets"; return 0;}
  219.  
  220.     kbytes=$(echo "$1 / 1024" | bc );
  221.     [ "$( echo "$kbytes < 1024" | bc)" == "1" ] && { echo -n "$kbytes Ko" ; return 0; }
  222.  
  223.     mbytes=$(echo "$kbytes / 1024" | bc );
  224.     [ "$( echo "$mbytes < 1024" | bc)" == "1" ] && { echo -n "$mbytes Mo" ; return 0; }
  225.     gbytes=$(echo "$mbytes / 1024" | bc );
  226.     [ "$( echo "$gbytes < 1024" | bc )" == "1" ] && { echo -n "$gbytes Go" ; return 0; }
  227.     tbytes=$(echo "$gbytes / 1024" | bc );
  228.     echo -n "$gbytes To"
  229.  
  230. }
  231.  
  232. function checkfile ()
  233. {
  234.     [ "$*" ] || print_syntax_error "$FUNCNAME: no arguments.";
  235.     [ "$3" ] && print_syntax_error "$FUNCNAME: too much arguments.";
  236.  
  237.  
  238.     for i in $(echo $1 | sed 's/\(.\)/ \1/g')
  239.     do
  240.     case "$i" in
  241.         "")
  242.             :
  243.         ;;
  244.                 "e")
  245.                         if ! [ -e "$2" ]
  246.             then 
  247.                             echo "'$2' is not found."
  248.                             return 1
  249.             fi;;
  250.         "f")
  251.             if ! [ -f "$2" ]
  252.             then
  253.                 echo "'$2' is not a regular file."
  254.                 return 1
  255.             fi;;
  256.         "d")
  257.             if ! [ -d "$2" ]
  258.             then
  259.                 echo "'$2' is not a directory."
  260.                 return 1
  261.             fi;;
  262.         "r")
  263.                     if ! [ -r "$2" ]
  264.             then
  265.                             echo "'$2' is not readable."
  266.                             return 1
  267.             fi;;
  268.                 "w")
  269.             if ! [ -w "$2" ]
  270.             then
  271.                             echo "'$2' is not writable."
  272.                             return 1
  273.             fi;;
  274.                 "x")
  275.                         if ! [ -x "$2" ]
  276.             then
  277.                             echo "'$2' is not executable/openable."
  278.                             return 1
  279.             fi;;
  280.         "l")
  281.             if ! [ -L "$2" ]
  282.             then
  283.                 echo "'$2' is not a symbolic link."
  284.                 return 1
  285.             fi;;
  286.     esac
  287.     done
  288.  
  289.     return 0;
  290. };
  291.  
  292.  
  293.  
  294. # === VARS :
  295. #
  296. # Feel free to change them.
  297.  
  298. max_err=5     # number of error to start a new chunk
  299.               # DO NOT SET TO "1"...
  300. min_bs=512    # min block size (see dd_rescue's help)
  301. max_bs=16384  # max block size (see dd_rescue's help)
  302. bar_lines=15  # nb of lines for bar drawing.
  303.  
  304.  
  305. # === CODE : 
  306. #
  307. #
  308.  
  309.  
  310. function get_path
  311. {
  312.     echo $(type -p $1) 
  313. }
  314.  
  315. function require_exe 
  316. {
  317.     path=$(get_path $1)
  318.  
  319.     if test -z "$path" ; then
  320.     print_error "requires '$1' to run... And it couldn't find it." >&2
  321.     exit 1
  322.     else
  323.     echo $path
  324.     fi
  325. }
  326.  
  327. # checks each required program and get their path.
  328. SED=$(require_exe sed) || exit 1
  329. GREP=$(require_exe grep) || exit 1
  330. CAT=$(require_exe cat) || exit 1
  331. CUT=$(require_exe cut) || exit 1
  332. TR=$(require_exe tr) || exit 1
  333. HEAD=$(require_exe head) || exit 1
  334. TAIL=$(require_exe tail) || exit 1
  335. TOUCH=$(require_exe touch) || exit 1
  336. WC=$(require_exe wc) || exit 1
  337. BC=$(require_exe bc) || exit 1
  338. tr=$(require_exe tr) || exit 1
  339.  
  340. # usage string :
  341. usage="$exname {filename|device} {output-file} [{info}]
  342.     or $exname --help
  343.     or $exname --version"
  344.  
  345. #
  346. # === Argument checking...
  347. #
  348.  
  349. if [ "$#" == "1" ]; then
  350.  
  351.     if [ "$1" == "--help" ]; then
  352.     print_usage
  353.     "${CAT}" <<EOF
  354.  
  355. Options:
  356.   --help            Print this message
  357.   --version         Print version information
  358.   {filename|device} The source file (it can be a block device)
  359.   {output-file}     The destination file
  360.   info              Specifying "info" as third argument will display 
  361.                       summary informations on ongoing recovery and
  362.               exit without taking any actions.
  363.  
  364. Note:
  365.   A log file will be created, and named '<output-file>.log'. This is a
  366. dd_rescue log file (which is human readable). This log file is important
  367. as dd_rhelp feeds itself with its contents to manage correctly dd_rescue.
  368.  
  369. Send bug reports, or comments to $email.
  370. Sorry for the shitty programming style.
  371. EOF
  372.     exit
  373.     fi
  374.  
  375.     if [ "$1" == "--version" ] ; then
  376.     "${CAT}" <<EOF
  377. $exname $version ($state)
  378. EOF
  379.     exit
  380.     fi
  381.  
  382.     echo "Need 2 arguments..."
  383.     print_usage
  384.     exit 1
  385. fi
  386.  
  387.  
  388.  
  389. if [ "$1" == "" ] 
  390. then
  391.     echo "Need 2 arguments..."
  392.     print_usage
  393.     exit 1;
  394. fi
  395.  
  396. if [ "$3" != "" ] && [ "$3" != "info" ]
  397. then
  398.     shift;shift
  399.     echo "too much argument... : '$*' is beyond limit. "
  400.     print_usage
  401.     exit 1;
  402. fi
  403.  
  404. if [ "$3" == "info" ]
  405. then
  406.  opt="info"
  407. fi
  408.  
  409. infile="$1"
  410. outfile="$2"
  411. logfile="$2.log"
  412.  
  413. #
  414. # === Files checking
  415. #
  416.  
  417.  
  418. if ! checkfile er "$infile"
  419. then
  420.     print_error "'$infile' is not accessible..."
  421.     exit 1;
  422. fi
  423.  
  424. if ! checkfile erw "$outfile" > /dev/null 2>&1
  425. then
  426.  
  427.     if ! "${TOUCH}" "$outfile" > /dev/null 2>&1
  428.     then
  429.     print_error "'$outfile' is not accessible/could not be created..."
  430.     else
  431.     [ "$DEBUG" == "on" ] && 
  432.        echo "- file '$outfile' was successfully touched..."
  433.     fi
  434. fi
  435.  
  436. if ! checkfile erw "$logfile" > /dev/null 2>&1
  437. then
  438.  
  439.     if [ "$opt" == "info" ] && ! [ -r "$logfile" ]
  440.     then
  441.     "${CAT}" <<EOF
  442. No info available since there's no readable '$logfile'.
  443.  
  444. 'info' option outputs information on current rescuing state by parsing this 
  445. log file that would have been created by a precedent use of dd_rhelp or 
  446. dd_rescue. Since there's no log file, it has nothing to display.
  447.  
  448. This happens if you haven't launched a dd_rhelp before.
  449. EOF
  450.     exit 0 ;
  451.     fi
  452.   
  453.  
  454.  
  455.     if ! "${TOUCH}" "$logfile" > /dev/null 2>&1
  456.     then
  457.     print_error "'$logfile' is not accessible/could not be created..."
  458.     else
  459.     [ "$DEBUG" == "on" ] && 
  460.        echo "- file '$logfile' was successfully touched..."
  461.     fi
  462. else
  463.     if [ "$opt" == "info" ] && [ "$(${CAT} "$logfile" | grep -v ^\$ )" == "" ] ; then
  464.     "${CAT}" <<EOF
  465. No info available in '$logfile' : it is empty !
  466.  
  467. 'info' option outputs information on current rescuing state by parsing this 
  468. log file that would have been created by a precedent use of dd_rhelp or 
  469. dd_rescue. Since there's no content in log file, it has nothing to display.
  470.  
  471. This could happens if you haven't launched a dd_rhelp before.
  472. EOF
  473.     exit 0 ;
  474.     fi
  475.  
  476. fi
  477.  
  478.  
  479. #
  480. # === Some vars, do not touch unless you know what you are doing...
  481. #
  482.  
  483. # regexp for parsing the log file.
  484.  
  485. string="^Summary for $infile -> $outfile:"
  486. infoline="^dd_rescue: (info):"
  487. eofstring="$infoline $infile ([0-9]\+\.[0-9]k): EOF\$"
  488. nb_stars=$[ $bar_lines * $COLUMNS ] # nb of char to display progress bar...
  489.  
  490. #
  491. # === Functions
  492. #
  493.  
  494. # Variable that holds chunks info in a list of
  495. # lines of nb1-nb2...
  496. chunk=""
  497.  
  498.  
  499.  
  500. function get_valid_dd_rescue
  501. {
  502.  
  503.     [ "$DEBUG" == "on" ] && echo "Finding dd_rescue binary" >&2
  504.  
  505.     path=$(get_path dd_rescue)
  506.     
  507.     version=$("$path" -V 2>&1 | grep "dd_rescue Version" | cut -f 3 -d " " |
  508.     cut -f 1 -d ",")
  509.     
  510.     [ "$DEBUG" == "on" ] && echo -n "Trying '$path' : gives this version : '$version'..." >&2
  511.  
  512.     if is_num "$version" && [ "$(bc_calc 2 "$version < 1.03")" == "0" ]
  513.     then
  514.         [ "$DEBUG" == "on" ] && echo "OK !" >&2
  515.     if [ "$(bc_calc 2 "$version < 1.12")" == "0" ]
  516.         then
  517.         echo "$path -y0"
  518.         else
  519.         echo "$path"
  520.     fi
  521.     return 0
  522.     else
  523.     [ "$DEBUG" == "on" ] && echo "BAD !" >&2
  524.     fi
  525.     
  526.     path="$(dirname $(type -ap "$0" | "${TAIL}" -n 1))/dd_rescue"
  527.     
  528.     if [ -x "$path" ] ;then
  529.     version=$("$path" -V 2>&1 | grep "dd_rescue Version" | cut -f 3 -d " " |
  530.         cut -f 1 -d ",")
  531.     [ "$DEBUG" == "on" ] && echo -n "Trying '$path' : gives this version : '$version'..." >&2
  532.     if is_num "$version" && [ "$(bc_calc 2 "$version < 1.03")" == "0" ];then
  533.         [ "$DEBUG" == "on" ] && echo "OK !" >&2
  534.         echo "$path"
  535.         return 0
  536.     else
  537.         [ "$DEBUG" == "on" ] && echo "BAD !" >&2
  538.     fi
  539.     
  540.     fi
  541.     
  542.     echo "Bad version of dd_rescue ! you must have >= 1.03">&2
  543.     exit 1    
  544. };
  545.  
  546. # *** check whether $1 is num...
  547. # args : 
  548. #   $1 is string to be tested as num
  549. # returns errorlevel 0/1 depending on "$1"
  550. # std_out : nothing
  551. function is_num ()
  552. {
  553.     rest=$(echo $1 | sed 's/^\([0-9]\+\)\?\(\.\([0-9]\+\)\)\?$/X/g')
  554.     
  555.     if [ -z "$(echo $1 | grep '^\([0-9]\+\)\?\(\.\([0-9]\+\)\)\?$')" ] ;then
  556.     return 1
  557.     else
  558.     return 0
  559.     fi
  560. }
  561.  
  562. # *** Handles BC conveniently
  563. # args :
  564. #   $1  is scale (number of digit in result after '.')
  565. #   $2+ is expression to be parsed by bc
  566. # returns : errorlevel 0 if no error occured
  567. # std_out : output of bc 
  568. # quits program with errorlevel 1 if error occured
  569. #  and output a debug string.
  570. function bc_calc ()
  571. {
  572.     scale=$1;
  573.  
  574.     if ! is_num "$scale" && test "$scale" != "no"; then
  575.     echo "*** bc_calc: Wrong first argument " >&2
  576.     echo "*** '$scale' is not a number." >&2
  577.     exit 1
  578.     fi
  579.  
  580.     test "$scale" == "no" && scale=""
  581.  
  582.     shift
  583.     exp=$(test "$scale" && echo "scale=$scale;";
  584.     test "$*" && echo "$*" || "${CAT}" - )
  585.     
  586.     ans=$(echo "$exp" | "${BC}" 2>&1)
  587.  
  588.     if ! is_num "$ans"; then
  589.     echo "*** BC failed on this expression : " >&2
  590.     echo "$exp" >&2
  591.     echo "*** BC returned :" >&2
  592.     echo "$ans" >&2
  593.     exit 1;
  594.     else
  595.     echo "$ans"
  596.     return 0
  597.     fi    
  598. }
  599.  
  600. # Go fetch EOF information in log to get a good approximation
  601. # no args
  602. # Depends on content of logfile.
  603. # errorlevel allways 0
  604. # return nothing
  605. # changes $eof to "nothing" if no EOF is found,
  606. #              or 'nb' where nb is best EOF found
  607. function get_eof()
  608. {
  609.  
  610.   eoflines="$("${CAT}" "$logfile" | "$tr" -d "\\r" | "$GREP" "$eofstring" | "$SED" 's/^dd_rescue: (info): .* (\([0-9\.]\+\)k): EOF$/\1/g')"
  611.  
  612.   eof="nothing"
  613.  
  614.   for i in $eoflines
  615.   do
  616.     if [ "$eof" == "nothing" ]; then
  617.     eof=$i
  618.     continue
  619.     fi
  620.  
  621.     if [ "$(bc_calc 1 "$eof > $i")" == "1" ];then
  622.     eof=$i
  623.     continue
  624.     fi
  625.   done
  626. }
  627.  
  628.  
  629. # Will mark chunk as beiing completed
  630. # Depends on '$chunk', $chunk MUST be correctly generated !!
  631. # args :
  632. #   "nb1-nb2" with nb1<nb2
  633. # Modifies '$chunk'.
  634. function add_chunk()
  635. {
  636.     arg_start=$(echo "$1" | "${CUT}" -f 1 -d "-")
  637.     arg_stop=$(echo "$1" | "${CUT}" -f 2 -d "-")
  638.  
  639.     if ! is_num "$arg_start" ||
  640.     ! is_num "$arg_stop"; then
  641.     print_error "*** add_chunk : invalid argument '$1' (is not correctly formatted as number:number)"
  642.     fi
  643.  
  644.     if test "$(bc_calc 1 "$arg_start < $arg_stop")" == "0"; then
  645.     print_error "*** add_chunk : invalid argument '$1' (these are not logical values)"
  646.     fi
  647.  
  648.     overlap="no"
  649.  
  650.     goodchunk=""
  651.     parsechunk="$chunk"
  652.  
  653.     while test "$parsechunk"
  654.     do
  655.  
  656.       # get first chunk already marked.
  657.       i="$(echo "$parsechunk" | "${HEAD}" -n 1 )"
  658.  
  659.       # pull the two bounds
  660.       i_start="$(echo "$i" | "${CUT}" -f 1 -d "-")"
  661.       i_stop="$(echo "$i" | "${CUT}" -f 2 -d "-")"
  662.  
  663.  
  664.       # new chunk begins after current chunk end ?
  665.       as_gt_ie="$(bc_calc 1 "$arg_start > $i_stop" )"
  666.  
  667.       if [ "$as_gt_ie" == "1" ]
  668.       then
  669.           # new chunk doesn't overlap with current chunk
  670.       # Iterate, put current chunk in $goodchunk.
  671.       goodchunk="$(echo -en "$goodchunk\n$i")"
  672.       parsechunk="$(echo "$parsechunk" | "${TAIL}" -n +2)"
  673.       continue
  674.       fi
  675.  
  676.       # new chunk ends before current chunk start ?
  677.       ae_gt_is="$(bc_calc 1 "$arg_stop < $i_start")"
  678.  
  679.       
  680.       if [ "$ae_gt_is" == "1" ]
  681.       then
  682.           # new chunk doesn't overlap with current chunk but is before
  683.       # we have found where to put our chunk
  684.  
  685.       break; # we can break because chunk are sorted
  686.       fi
  687.       
  688.       # if we come here, that means that new chunk overlap with current.
  689.       
  690.       # have we new chunk's start located IN current chunk ?
  691.       as_int="$(bc_calc 1 "$arg_start >= $i_start && $arg_start <= $i_stop")"
  692.  
  693.       # have we new chunk's end located IN current chunk ?
  694.       ae_int="$(bc_calc 1 "$arg_stop >= $i_start && $arg_stop <= $i_stop ")"
  695.  
  696.       # new chunk is contained entirely in current chunk
  697.       if [ "$as_int" == "1" ] && [ "$ae_int" == "1" ]
  698.       then
  699.       # no need to do anything
  700.       overlap="yes"
  701.       break;
  702.       fi
  703.  
  704.       # new chunk contains entirely current chunk
  705.       if [ "$as_int" == "0" ] && [ "$ae_int" == "0" ]
  706.       then
  707.       # we forget about current chunk, and iterate.
  708.       parsechunk=$(echo "$parsechunk" | "${TAIL}" -n +2)
  709.       continue
  710.       fi
  711.       
  712.       # new chunk overlap on its end with beginning of current chunk
  713.       if [ "$as_int" == "0" ] && [ "$ae_int" == "1" ]
  714.       then
  715.       # grow new chunk to englobe current chunk.
  716.       arg_stop=$i_stop
  717.       parsechunk=$(echo "$parsechunk" | "${TAIL}" -n +2)
  718.  
  719.       break; # we can break because chunk are sorted.
  720.       fi
  721.  
  722.       # new chunk overlap on its beginning with end of current chunk
  723.       if [ "$as_int" == "1" ] && [ "$ae_int" == "0" ]
  724.       then
  725.       # grow new chunk to englobe current chunk.
  726.       arg_start=$i_start
  727.       parsechunk=$(echo "$parsechunk" | "${TAIL}" -n +2)
  728.       continue; # new chunk might overlap more chunks
  729.       fi
  730.  
  731.     done
  732.  
  733.     # Overlapping occurs only if new chunk is contained in already marked
  734.     # chunk. In this case, we musn't change $chunk.
  735.     if [ "$overlap" == "no" ]
  736.     then
  737.     chunk="$(echo -en "$goodchunk\n$arg_start-$arg_stop\n$parsechunk" |
  738.      "$GREP" -v ^\$)"
  739.     fi
  740. }
  741.  
  742.  
  743. # get_next_pos will found the next offset to jump at to launch dd_rescue
  744. # No args
  745. # depends on $eof
  746. # returns offset:long  (offset in start location, long is how much bytes
  747. #                         to retrieve from location both reverse and forth)
  748. function get_next_pos()
  749. {
  750.    if [ "$eof" == "nothing" ] || test -z "$eof" 
  751.    then
  752.  
  753.     # finding last's chunk end.
  754.  
  755.     if test "$chunk" ;then
  756.        last_chunk=$(echo "$chunk" | "${TAIL}" -n 1 )
  757.        max_stop=$(echo "$last_chunk" | "${CUT}" -f 2 -d "-")
  758.         else           
  759.            max_stop=0
  760.     fi
  761.     
  762.     echo "$(bc_calc 1 "($max_stop * 2)"):$max_stop";
  763.        
  764.     else
  765.  
  766.     # find biggest hole.
  767.     pos=0
  768.     size=0
  769.     cursize=0
  770.     start=0
  771.     next=0
  772.  
  773.     # Get biggest hole between chunks
  774.     for i in $chunk "$eof-$eof"
  775.         do
  776.  
  777.       # collect start of chunk
  778.       next=$(echo "$i" | "${CUT}" -f 1 -d "-")
  779.  
  780.       if [ "$next" != "$start" ]
  781.       then
  782.           cursize="$(bc_calc 1 "($next - $start)")"
  783.           if [ "$(bc_calc 1 "($size < $cursize)")" == "1" ]
  784.           then
  785.               size=$cursize
  786.               pos=$start
  787.           fi
  788.       fi
  789.       start=$(echo "$i" | "${CUT}" -f 2 -d "-")
  790.     done
  791.  
  792.     size="$(bc_calc 0 "(($size + 1) / 2)")"
  793.     echo "$(bc_calc 1 "($pos + $size)"):$size"
  794.     fi
  795. }
  796.  
  797.  
  798. # Get info with last summary produced by dd_rescue call.
  799. # no args
  800. # depends on content of log file
  801. # changes $logcontent, $chunk, $eof 
  802. function swallow_last_summary()
  803. {
  804.   # last summary of log (4 lines output by printreport())
  805.   last_logcontent=$("${CAT}" "$logfile" | "$tr" -d "\\r" | "$GREP" "$string" -A 3 | "${TAIL}" -n 4)
  806.   process_log "$last_logcontent"
  807.  
  808.   get_eof
  809.  
  810.   save_log
  811.   
  812. }
  813.  
  814.  
  815.  
  816. function get_last_chunk()
  817. {
  818.     if test "$chunk"; then
  819.     last_chunk="$(echo "$chunk" | "${TAIL}" -n 1 )"
  820.     echo "$last_chunk" | "${CUT}" -f 2 -d "-"
  821.     else
  822.     echo 0
  823.     fi
  824. };
  825.  
  826.  
  827. # Display a neat bar in ascii art(?!) which shows completion of dd_rescue.
  828. # 
  829. #
  830. #
  831. function show_bar()
  832. {
  833.  
  834.     echo "=== BAR === [ 'x' dd_rescued, '*' next jump point, '|' '.' not dd_rescued ]"
  835.  
  836.     if [ "$eof" == "nothing" ] || test -z "$eof"
  837.     then
  838.     eof_limit="$(get_last_chunk)"
  839.     next_pos="$(get_next_pos | "${CUT}" -f 1 -d ":")"
  840.     if [ "$(bc_calc 1 "$eof_limit < $next_pos")" == "1" ]; then
  841.         eof_limit=$next_pos
  842.     fi
  843.     else
  844.     eof_limit="$eof";
  845.     fi
  846.  
  847.     if ! is_num "$nb_stars";then
  848.     nb_stars=80
  849.     fi
  850.     
  851.  
  852.     if [ "$eof_limit" != "0" ]
  853.     then
  854.     
  855.     # c_res is nb of Kb represented by one char.
  856.     c_res="$(bc_calc 10 "$eof_limit / $nb_stars")";
  857.  
  858.     # next_pos is place of next jump in chars.
  859.     next_pos="$(bc_calc 0 "$(get_next_pos | "${CUT}" -f 1 -d ":") / $c_res")";    
  860.         
  861.  
  862. #    echo -n "[";
  863.  
  864.     curchar=0
  865.     start=0
  866.     next=0
  867.     ct=0
  868.  
  869.     for i in $chunk $eof_limit-$eof_limit
  870.       do
  871.  
  872.       start=$(echo "$i" | "${CUT}" -f 1 -d "-")
  873.       
  874.       if [ "$next" != "$start" ]
  875.       then
  876.  
  877.           # This is start of hole
  878.           startchar="$(bc_calc 0 "$next / $c_res")"
  879.     
  880.           # This is end of hole
  881.           curchar="$(bc_calc 0 "$start / $c_res")"
  882.                     
  883.           # draw completed chars up to start of hole.
  884.           while [ "$ct" -lt "$startchar" ] ;do
  885.         echo -n "x"
  886.         ct=$[$ct+1] ;
  887.           done
  888.  
  889.           # our current tracker ($ct) is now at : $ct==$startchar
  890.           # OR is $ct = $startchar + 1 ONLY if precedent hole finished
  891.           #    in the same char this hole begins !!
  892.           
  893.           # as rounding occurs, we might have $startchar == $curchar
  894.           # but original hole is not null ! We must show that there's
  895.           # a hole in this char.
  896.  
  897.               # hole is bigger than 1 char 
  898.           if [ "$startchar" -lt "$curchar" ] ; then
  899.           # if current drawing position ($ct) is on startchar
  900.           if [ "$ct" == "$startchar" ] ;then
  901.               # draw the beginning of hole.
  902.               [ "$ct" != "$next_pos" ] && echo -n "|" || echo -n "*"
  903.               ct=$[$ct + 1] 
  904.           fi
  905.           
  906.           # mark char between startchar and curchar as hole.
  907.           while [ "$ct" -lt "$curchar" ] ; do
  908.             [ "$ct" != "$next_pos" ] && echo -n "." || echo -n "*"
  909.             ct=$[$ct + 1]
  910.           done
  911.  
  912.           # current tracker is now equal to curchar.
  913.  
  914.           # draw the end of hole.
  915.           if [ "$nb_stars" -gt "$curchar" ] ; then
  916.               [ "$ct" != "$next_pos" ] && echo -n "|" || echo -n "*"
  917.               ct=$[$ct + 1]
  918.           fi
  919.  
  920.           else
  921.           
  922.           # the only remaining possibility is that $startchar=$curchar
  923.           # this is the rounding possibility.
  924.  
  925.           # if [ "$startchar" == "$curchar" ] ; then
  926.               if [ "$nb_stars" -gt "$curchar" ] ; then
  927.               if [ "$ct" == "$next_pos" ] ; then
  928.                   [ "$ct" != "$next_pos" ] && echo -n "|" || 
  929.                   echo -n "*"
  930.                   ct=$[$ct + 1]
  931.               fi
  932.               fi
  933.           # fi
  934.               
  935.           fi
  936.       else
  937.           if [ "$start" == "$eof_limit" ]; then
  938.           while [ "$ct" -lt "$nb_stars" ] ;do
  939.               echo -n "x"
  940.               ct=$[$ct+1] ;
  941.           done
  942.           fi
  943.       fi
  944.       next=$(echo "$i" | "${CUT}" -f 2 -d "-")
  945.       
  946.     done
  947.  
  948.     else
  949.     echo -n "[ No Bar available the first launch ]"
  950.     fi
  951.  
  952.     last_chunk="$(get_last_chunk)"
  953.  
  954.     if [ "$eof_limit" != "$last_chunk" ]
  955.     then
  956.     echo "=== Bar was drawn from 0 to hypothetic end : $eof_limit"
  957.     else
  958.     echo "=== Bar was drawn from 0 to $eof_limit"
  959.     fi
  960. }
  961.  
  962.  
  963.  
  964. function show_info()
  965. {
  966.     echo "=== dd_rhelp INFO -" $(echo "$chunk" | "${WC}" -l) "chunks...";
  967.     jump=$(get_next_pos | "${CUT}" -f 1 -d ":")
  968.     [ "$jump" != "0" ] && echo -n "- Jump pos : $(get_next_pos | "${CUT}" -f 1 -d ":") "
  969.     if [ "$eof" == "nothing" ]
  970.     then
  971.       echo "- max file size : no limit found"
  972.     else
  973.       echo "- max file size : $eof"
  974.  
  975.       echo -en "- Biggest hole size : " "$(bc_calc 1 "$(get_next_pos | "${CUT}" -f 2 -d ":") * 2")" "k "
  976.     fi
  977.  
  978.   parsing="$logcontent"
  979.   total_errxfer="0";
  980.   total_succxfer="0";
  981.   total_xferd="0";
  982.  
  983.   while test "$parsing" 
  984.   do
  985.     firstline="$(echo "$parsing" | "${HEAD}" -n 1)"
  986.     parsing="$(echo "$parsing" | "${TAIL}" -n +2)"
  987.     
  988.     xferd="$(echo "$firstline" | "${CUT}" -f 2 -d ":" | "${CUT}" -f 2 -d "=")"
  989.     errxfer="$(echo "$firstline" | "${CUT}" -f 4 -d ":" | "${CUT}" -f 2 -d "=")"
  990.     succxfer="$(echo "$firstline" | "${CUT}" -f 5 -d ":" | "${CUT}" -f 2 -d "=")"
  991.  
  992.     total_errxfer="$(bc_calc 1 "$total_errxfer + $errxfer")"
  993.     total_succxfer="$(bc_calc 1 "$total_succxfer + $succxfer")"
  994.     total_xferd="$(bc_calc 1 "$total_xferd + $xferd")"
  995.  
  996.   done
  997.  
  998.  
  999.     size=0
  1000.     cursize=0
  1001.     start=0
  1002.     next=0
  1003.     for i in $chunk
  1004.     do
  1005.       next=$(echo "$i" | "${CUT}" -f 1 -d "-")
  1006.       if [ "$next" != "$start" ]
  1007.       then
  1008.       cursize="$(bc_calc 1 "$next - $start")"
  1009.       size="$(bc_calc 1 "$size + $cursize")"
  1010.       fi
  1011.       start=$(echo "$i" | "${CUT}" -f 2 -d "-")
  1012.     done
  1013.     echo -e "- total holes : ${size}k"
  1014.  
  1015.     echo -e "- xferd(succ/err) : ${total_xferd}k(${total_succxfer}k/${total_errxfer}k)"
  1016.  
  1017.     eof_limit=$(get_last_chunk)
  1018.  
  1019.     echo -en "- EOF "
  1020.  
  1021.     if  [ "$eof" != "nothing" ] && 
  1022.      [ "$eof" == "$eof_limit" ];then
  1023.     echo "is found and is at ${eof}k."
  1024.     else
  1025.     if [ "$eof" != "nothing" ]; then
  1026.         echo "is not found, but between ${eof_limit}k and ${eof}k."
  1027.     else
  1028.         echo "is not found, but greater than ${eof_limit}k"
  1029.     fi
  1030.     fi
  1031.  
  1032.     if [ "$size" == "0" ] && [ "$eof" != "nothing" ] && 
  1033.     [ "$eof" == "$eof_limit" ];then
  1034.     return 0
  1035.     else
  1036.     return 1
  1037.     fi
  1038. }
  1039.  
  1040.  
  1041. function process_log()
  1042. {
  1043.     data="$1"
  1044.  
  1045.     test -z data && return 0
  1046.     
  1047.     [ "$DEBUG" == "on" ] && echo -n "- cleaning data ["
  1048.     data=$(echo "$data" | "$GREP" -v "xferd: \+0.0k$")
  1049.     [ "$DEBUG" == "on" ] && echo -n "."
  1050.     data=$(echo "$data" | "$GREP" "$infoline" -A 1 | "${CUT}" -c 12-)
  1051.     [ "$DEBUG" == "on" ] && echo -n "."
  1052.     data=$(echo "$data" | "$SED" 's/^(info): ipos: \+//g')
  1053.     [ "$DEBUG" == "on" ] && echo -n "."
  1054.     data=$(echo "$data" | "$SED" 's/^ \+errs: \+/NR:/g')
  1055.     [ "$DEBUG" == "on" ] && echo -n "."
  1056.     data=$(echo "$data" | "$SED" 's/^ \+- \+errs: \+/RE:/g')
  1057.     [ "$DEBUG" == "on" ] && echo -n "."
  1058.     data=$(echo "$data" | "$SED" 's/^\([0-9\.]\+\)k, opos:.\+xferd: \+\([0-9\.]\+\)k$/ipos=\1:xferd=\2:/g')
  1059.     [ "$DEBUG" == "on" ] && echo -n "."
  1060.     data=$(echo "$data" | "$SED" 's/^\(RE\|NR\):[0-9]\+, errxfer: \+\([0-9\.]\+\)k, succxfer: \+\([0-9\.]\+\)k$/\1:errxfer=\2:succxfer=\3;/g')
  1061.     [ "$DEBUG" == "on" ] && echo -n "."
  1062.     data=$(echo "$data" | "${TR}" -d "\n")
  1063.     [ "$DEBUG" == "on" ] && echo -n "."
  1064.     data=$(echo "$data" | "${TR}" ";" "\n")
  1065.     [ "$DEBUG" == "on" ] && echo ".]"
  1066.     
  1067.     # All info now take one line per entry, and field are separated by ":"
  1068.  
  1069.     [ "$DEBUG" == "on" ] && echo -n "- processing data ["
  1070.     
  1071.   # finding start of chunks
  1072.     
  1073.     parsing="$data"
  1074.     # chunk=""
  1075.     
  1076.     while test "$parsing" ;do
  1077.     firstline="$(echo "$parsing" | "${HEAD}" -n 1)"
  1078.     parsing="$(echo "$parsing" | "${TAIL}" -n +2)"
  1079.     
  1080.     ipos="$(echo $firstline | "${CUT}" -f 1 -d ":" | "${CUT}" -f 2 -d "=")"
  1081.     xferd="$(echo $firstline | "${CUT}" -f 2 -d ":" | "${CUT}" -f 2 -d "=")"
  1082.     rev="$(echo $firstline | "${CUT}" -f 3 -d ":")"
  1083.     errxfer="$(echo $firstline | "${CUT}" -f 4 -d ":" | "${CUT}" -f 2 -d "=")"
  1084.     succxfer="$(echo $firstline | "${CUT}" -f 5 -d ":" | "${CUT}" -f 2 -d "=")"
  1085.     
  1086.     if [ "$rev" == "RE" ] ; then
  1087.         start="$ipos"
  1088.         stop="$(bc_calc 1 "$ipos + $xferd")"
  1089.     else
  1090.         start="$(bc_calc 1 "$ipos - $xferd")"
  1091.         stop="$ipos"
  1092.     fi
  1093.  
  1094.     chunkline="$start-$stop"
  1095.     add_chunk $chunkline
  1096.  
  1097.     [ "$DEBUG" == "on" ] && echo -n "."
  1098.     done
  1099.  
  1100.     [ "$DEBUG" == "on" ] && echo "]";
  1101.  
  1102.     if test "$logcontent";then
  1103.     logcontent="$(echo -en "$logcontent\n$data")"
  1104.     else
  1105.     logcontent="$data";
  1106.     fi
  1107. }
  1108.  
  1109. function load_log()
  1110. {
  1111. #
  1112. # loading into memory Summary info found in log file...
  1113. #
  1114.     # line number of last save_log entry...
  1115.     lnb_save=$("${CAT}" -n "$logfile" | "$tr" -d "\\r" | grep "chunk:" -A 2 | "${TAIL}" -n 3)
  1116.     
  1117.  
  1118.     if test "$lnb_save" ;then
  1119.     lnb_save=$(echo $lnb_save | "${HEAD}" -n 1 | cut -f 1 -d " ")
  1120.  
  1121.     end_log="$(cat "$logfile" | "$tr" -d "\\r" | "${TAIL}" -n "+$lnb_save")"
  1122.  
  1123.     last_lines=$(echo "$end_log" | grep "chunk:" -A 2 | "${TAIL}" -n 3)
  1124.     
  1125.     log=$(echo "$last_lines" | "$GREP" "chunk" | "${TAIL}" -n 1 )
  1126.     log1=$(echo "$last_lines" | "$GREP" "logcontent" | "${TAIL}" -n 1 )
  1127.     log2=$(echo "$last_lines" | "$GREP" "eof" | "${TAIL}" -n 1 )
  1128.     
  1129.     if test "$log" && test "$log1" && test "$log2" ;then
  1130.         chunk="$(echo "$log" | "${CUT}" -f 2- -d ":" | "${TR}" ":" "\n")"
  1131.  
  1132.         logcontent="$(echo "$log1" | "${CUT}" -f 2- -d : | "${TR}" ";" "\n")"
  1133.         eof="$(echo "$log2" | "${CUT}" -f 2 -d ":")"
  1134.         
  1135.         log=$(echo "$end_log" | "$GREP" "$string" -A 3 )
  1136.         
  1137.         process_log "$log"
  1138.         return 0
  1139.     else
  1140.         echo "Bad log format !!! Fallback to slow mode..."
  1141.     fi
  1142.  
  1143.     fi
  1144.     
  1145.     # select all summary info of dd_rescue
  1146.     log=$("${CAT}" "$logfile" | "$tr" -d "\\r" | "$GREP" "$string" -A 3 )
  1147.  
  1148.     # Set EOF with log.
  1149.     get_eof
  1150.  
  1151.     # Sets logcontent AND chunk
  1152.     process_log "$log"
  1153.  
  1154. }
  1155.  
  1156. function save_log()
  1157. {
  1158.     echo "=== COMPUTED VERSION OF LOG :" >> "$logfile"
  1159.     echo "chunk:$(echo -n "$chunk" | "${TR}" "\n" : )" >> "$logfile"
  1160.     echo "logcontent:$(echo -n "$logcontent" | "${TR}" "\n" ";" )" >> "$logfile"
  1161.     echo "eof:$eof" >> "$logfile"
  1162. }
  1163.  
  1164.  
  1165.  
  1166. # === beginning of real code
  1167.  
  1168. load_log
  1169.  
  1170. # Save computed version of log for next time.
  1171. save_log
  1172.  
  1173. if [ "$opt" == "info" ] && test -z "$logcontent"
  1174. then
  1175.     echo "No Info found in log..."
  1176.     exit 0;
  1177. fi
  1178.  
  1179. if [ "$opt" != "info" ];then
  1180.     DD_RESCUE="$(get_valid_dd_rescue)"
  1181.     [ "$?" != "0" ] && exit 1
  1182. else
  1183.     echo "$(show_info)"
  1184.     if [ "$?" == "0" ] ; then 
  1185.        echo "ALL your data has been dd_rescued !!"
  1186.     else 
  1187.        show_bar
  1188.     fi
  1189.     exit 0
  1190. fi
  1191.  
  1192. while [ "$(echo "$chunk" | "${WC}" -l)" != "1" ] ||
  1193.       [ "$(get_last_chunk)" != "$eof" ] ||
  1194.       [ "$eof" == "nothing" ]
  1195. do
  1196.  
  1197.   info="$(show_info)" 
  1198.   if [ "$?" == "0" ] ; then 
  1199.       echo "$info"
  1200.       echo "ALL your data has been dd_rescued !!"
  1201.       # show_bar
  1202.       exit 0
  1203.   fi
  1204.   
  1205.   if [ "$logcontent" != "" ] ;then
  1206.       echo "$info";
  1207.       show_bar
  1208.   fi
  1209.  
  1210.  
  1211.   [ "$DEBUG" == "on" ] && [ "$opt" == "info" ] && [ "$chunk" != "" ] && echo -en "Chunks that were dd_rescued (in k):\
  1212.  \n$chunk\n"
  1213.   [ "$opt" == "info" ] && exit 1;
  1214.  
  1215.   next_pos="$(get_next_pos | "${CUT}" -f 1 -d ":")k"
  1216.   count="$(get_next_pos | "${CUT}" -f 2 -d ":")k"
  1217.  
  1218.  
  1219.   if [ "$next_pos" != "0k" ]
  1220.   then
  1221.       echo "=== launched via '$exname' at $next_pos, $count <<< ===" >> "$logfile"
  1222.       echo "=== launched via '$exname' at $next_pos, $count <<< ==="
  1223.       ${DD_RESCUE} -r -s "$next_pos" -l "$logfile" -e "$max_err" -B "$min_bs" -b "$max_bs" -m "$count" "$infile" "$outfile"
  1224.       swallow_last_summary
  1225.   fi
  1226.  
  1227.   if [ "$next_pos" != "${eof}k" ]
  1228.   then
  1229.       if [ "$eof" == "nothing" ]
  1230.       then
  1231.       count=0;
  1232.       fi
  1233.  
  1234.       echo "=== launched via '$exname' at $next_pos, $count >>> ===" >> "$logfile"
  1235.       echo "=== launched via '$exname' at $next_pos, $count >>> ==="
  1236.       ${DD_RESCUE} -s "$next_pos" -l "$logfile" -e "$max_err" -B "$min_bs" -b "$max_bs" -m "$count" "$infile" "$outfile"
  1237.       swallow_last_summary
  1238.   fi
  1239.  
  1240. done
  1241. # End dd_rhelp
  1242.