/[clonezilla-sysresccd]/trunk/create-clonezilla-sysresccd/files/reloc-img
ViewVC logotype

Contents of /trunk/create-clonezilla-sysresccd/files/reloc-img

Parent Directory Parent Directory | Revision Log Revision Log


Revision 48 - (show annotations)
Thu May 20 12:38:55 2010 UTC (11 years, 6 months ago) by sng
File size: 45524 byte(s)
- adding isofiles directory
- fixing license info on scripts

1 #!/bin/bash
2 ##############################################################################
3 # #
4 # reloc-img, (C) 2007-2010 S. Georgaras <sng@hellug.gr> #
5 # #
6 # This file is part of Clonezilla-SysRescCD. #
7 # #
8 # Clonezilla-SysRescCD is free software: you can redistribute it and/or #
9 # modify it under the terms of the GNU General Public License as published #
10 # by the Free Software Foundation, either version 2 of the License, or #
11 # (at your option) any later version. #
12 # #
13 # Clonezilla-SysRescCD is distributed in the hope that it will be useful, #
14 # but WITHOUT ANY WARRANTY; without even the implied warranty of #
15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
16 # GNU General Public License for more details. #
17 # #
18 # You should have received a copy of the GNU General Public License along #
19 # with Clonezilla-SysRescCD. If not, see <http://www.gnu.org/licenses/>. #
20 # #
21 ##############################################################################
22
23 # DEBUG=true
24 versionNumber='0.7'
25
26 function findDirectories(){
27 #
28 # <- selectedInputPartition
29 #
30 # -> activeDirectory - selected directory
31 #
32
33 local lines
34 local dialogLines
35 local cur=1
36 local cmdLine=''
37 local thisLine
38
39 local allDirs="$(find "$1" -maxdepth 1 -type d | sed 's|^\.$|/|' | sed '/ /d' | sed 's|^\./||' | sed "s|$1/||" | sed "s|$1||" | sed 's|^$|/|' | sort)"
40 lines="$(echo "$allDirs" | wc -l | sed 's|[ ]*||g')"
41 if [ "$lines" = "" ] || [ "$lines" = "0" ];then
42 activeDirectory='/'
43 return
44 fi
45
46
47 while [ "$cur" -le "$lines" ];do
48 thisLine="$(echo "$allDirs" | sed -n "$cur"p)"
49 cmdLine="$cmdLine"\"$thisLine\"" "
50 if [ "$thisLine" = "/" ];then
51 cmdLine="$cmdLine"" \"Top directory in the local device\" "
52 else
53 cmdLine="$cmdLine"\""$(ls -lad "$1"/"$thisLine" | awk '{print $6 " " $7}')\" "
54 fi
55 ((cur++))
56 done
57
58 # echo "$cmdLine"
59 # exit
60
61 if [ "$lines" -gt 10 ];then
62 dialogLines=10
63 else
64 if [ "$lines" -lt 4 ];then
65 dialogLines=4
66 else
67 dialogLines="$lines"
68 fi
69 fi
70
71 echo "dialog --backtitle \"$backTitle\" --title \" Select directory \" --menu 'Please select the directory that holds your images' $((dialogLines+7)) 78 $dialogLines $cmdLine" > /root/dialog.$$
72
73 . /root/dialog.$$ 2>/root/selectedDirectory.$$
74
75 activeDirectory=$(cat /root/selectedDirectory.$$)
76
77 rm /root/dialog.$$
78 }
79
80 function findSystemPartitions(){
81 # <- NONE
82 #
83 # -> selectedInputPartition - the partition to scan for images
84 # -> selectedInputPartitionNumber - Index of selectedInputPartition in inputPartition array
85 #
86 # -> diskCount - Number of disks on the system
87 # -> inputDisk - Disks present on the system (array)
88 # -> diskSize - Size of each disk (array)
89 #
90 # -> partitionCount - Number of partitions on the system
91 # -> inputPartition - Partitions present on the system (array)
92 # -> partitionSize - The size of each partition (array)
93 # -> partitionType - The type of each partition (array)
94 # -> CD - Not empty if partition is a CD (array)
95 #
96 allDisks=$(cat /proc/partitions | sed 's|.* ||' | grep -ve '[0-9]$'| grep -v name |grep -ve '^$')
97
98 [ -z "$allDisks" ] && {
99 dialog --backtitle "$backTitle" --title " No disks found!!! " --msgbox "There seems to be no disk connected to your system, therefore no restoration is possible" 7 70
100 cleanUP
101 exit 1
102 }
103
104
105 local cmdLine=''
106 diskCount=$(echo "$allDisks" | wc -l)
107
108 local fDisks=''
109
110 local count=1
111 while [ $count -le $diskCount ];do
112 inputDisk[$count]=$(echo "$allDisks" | sed -n ""$count"p")
113 fdisk -l /dev/"${inputDisk[$count]}" 2>/dev/null > /root/clsys-raw-fdisk-"$count".$$
114 # parted /dev/"${inputDisk[$count]}" print > /root/clsys-raw-parted-"$count".$$
115 diskSize[$count]=$(sed -n '1p' /root/clsys-raw-fdisk-"$count".$$ | sed 's|.*, ||' | sed 's| bytes||' | sed 's| ||g')
116 cat /root/clsys-raw-fdisk-"$count".$$ | grep -e '^/' | grep -v "Ext'd" | grep -ve "[Ee]xtended" | grep -ve '[sS][wW][aA][pP]' > /root/clsys-part-"$count".$$
117 ((count++))
118 done
119 # echo 33
120
121 allPartitions=$(cat /root/clsys-part-*$$ | sed 's| .*||' | sed 's|/dev/||')
122 # allSizes=$(grep -e '^ [0-9]' /root/clsys-raw-parted-*.$$ | awk '{print $4}')
123 partitionCount=$(echo "$allPartitions" | wc -l)
124
125 local cmdLine=''
126 count=1
127 while [ $count -le $partitionCount ];do
128 inputPartition[$count]=$(echo "$allPartitions" | sed -n ""$count"p")
129 getPartitionSizeFromFdisk "${inputPartition[$count]}"
130 partitionSize[$count]=$( echo "$THIS_PARTITION_SIZE" | sed 's|,|.|')
131 partitionType[$count]=$(grep "${inputPartition[$count]}" /root/clsys-raw-fdisk-*.$$| sed 's|*||' | awk '{printf "%s %s %s %s",$6,$7,$8,$9}' |sed 's| *$||')
132 cmdLine="$cmdLine""${inputPartition[$count]}"" ""\"Size: ${partitionSize[$count]}, Type: ${partitionType[$count]}\""" "
133
134 ((count++))
135 done
136
137 # cleanUP
138 # exit
139
140 # integrate CD-ROMs
141 local theCDs=$(cat /proc/sys/dev/cdrom/info | grep 'drive name' |sed 's|drive name:[ \t]*||' | awk '{for(i=1;i<=NF;i++) print $i}')
142 local cdCount=$(echo "$theCDs" | wc -l)
143
144 count=1
145 while [ $count -le $cdCount ];do
146 ((partitionCount++))
147 inputPartition[$partitionCount]=$(echo "$theCDs" | sed -n ""$count"p")
148 CD[$partitionCount]=$count
149 cmdLine="$cmdLine""${inputPartition[$partitionCount]}"" ""\"Type: CD-ROM\""" "
150 ((count++))
151 done
152
153 # integrate samba shares (cifs)
154 local smbShares=$(mount | sort | grep -e '[ ]cifs[ ]'| sed 's|on ||' |sed 's|type ||' | awk '$3 == "cifs" {print $2}')
155 #### DEBUG ####
156 [ -z "$DEBUG" ] || smbShares='/data'
157 #### END DEBUG ####
158
159 [ -z "$smbShares" ] || {
160 local smbCount=$(echo "$smbShares" | wc -l)
161 count=1
162 while [ $count -le $smbCount ];do
163 ((partitionCount++))
164 inputPartition[$partitionCount]=$(echo "$smbShares" | sed -n ""$count"p")
165 SMB[$count]=$partitionCount
166 cmdLine="$cmdLine"smb"$count"" ""\"Type: Samba Share, $(echo "${inputPartition[$partitionCount]}"|sed 's|.*/||')\""" "
167 ((count++))
168 done
169 }
170
171
172 local nfsShares=$(mount | sort | grep -e '[ ]nfs[ ]'| sed 's|on ||' |sed 's|type ||' | awk '$3 == "nfs" {print $2}')
173 #### DEBUG ####
174 [ -z "$DEBUG" ] || nfsShares='/data'
175 #### END DEBUG ####
176 [ -z "$nfsShares" ] || {
177 local nfsCount=$(echo "$nfsShares" | wc -l)
178 count=1
179 while [ $count -le $nfsCount ];do
180 ((partitionCount++))
181 inputPartition[$partitionCount]=$(echo "$nfsShares" | sed -n ""$count"p")
182 NFS[$count]=$partitionCount
183 cmdLine="$cmdLine"nfs"$count"" ""\"Type: NFS Share, $(echo "${inputPartition[$partitionCount]}"|sed 's|.*/||')\""" "
184 ((count++))
185 done
186 }
187 # echo 66
188 selectedInputPartition=''
189
190 echo "dialog --backtitle \"$backTitle\" --title \" Source Partition \" --menu 'Please select the location of your image file' $((partitionCount+7)) 78 $partitionCount $cmdLine" > /root/dialog.$$
191
192 . /root/dialog.$$ 2>/root/selectedPartition.$$
193
194 selectedInputPartition=$(cat /root/selectedPartition.$$)
195
196 # set -x
197 # cleanUP
198 # exit
199
200
201 [ -z "$selectedInputPartition" ] && {
202 cleanUP
203 exit
204 }
205
206 if [ ! -z $(echo "$selectedInputPartition"|grep -e '^smb[0-9][0-9]*$') ];then
207 local num=$(echo "$selectedInputPartition"|sed 's|smb||')
208 selectedInputPartitionNumber=${SMB[$num]}
209 workingRemote='y'
210 elif [ ! -z $(echo "$selectedInputPartition"|grep -e '^smb[0-9][0-9]*$') ];then
211 local num=$(echo "$selectedInputPartition"|sed 's|nfs||')
212 selectedInputPartitionNumber=${NFS[$num]}
213 workingRemote='y'
214 else
215 count=1
216 while [ "${inputPartition[$count]}" != "$selectedInputPartition" ];do
217 ((count++))
218 done
219 selectedInputPartitionNumber=$count
220 fi
221 # echo 100
222 # echo EOF
223 # read
224 # cleanUP
225 # exit
226
227 }
228
229 function findSambaShare(){
230 # used only when -i smb
231 echo 'Looking for Samba Shares (this may take some time)... '
232 partitionCount=0
233 local smbShares=$(mount | sort | awk '/cifs/ {
234 for(x=1; x<=NF; ++x){
235 s=substr($x,1,2)
236 if(s!="//"){
237 s=substr($x,1,1)
238 if(s=="/") mountpoint=$x
239 }if($x=="cifs"){
240 if(mountpoint!="") print mountpoint
241 }}}')
242 #### DEBUG ####
243 [ -z "$DEBUG" ] || smbShares='/data'
244 #### END DEBUG ####
245 [ -z "$smbShares" ] && {
246 echo
247 echo "No Samba Shares mounted"
248 exit 1
249 }
250 local smbCount=$(echo "$nfsShares" | wc -l)
251 count=1
252 while [ $count -le $smbCount ];do
253 ((partitionCount++))
254 inputPartition[$partitionCount]=$(echo "$smbShares" | sed -n ""$count"p")
255 SMB[$count]=$partitionCount
256 ((count++))
257 done
258 local num=1
259 selectedInputPartitionNumber=${SMB[$num]}
260 echo
261 }
262
263 function findNFSShare(){
264 # used only when -i nfs
265 echo 'Looking for NFS Shares (this may take some time)... '
266 partitionCount=0
267 local nfsShares=$(mount | sort | awk '/nfs/ {
268 for(x=1; x<=NF; ++x){
269 s=substr($x,1,2)
270 if(s!="//"){
271 s=substr($x,1,1)
272 if(s=="/") mountpoint=$x
273 }if($x=="nfs"){
274 if(mountpoint!="") print mountpoint
275 }}}')
276 #### DEBUG ####
277 [ -z "$DEBUG" ] || nfsShares='/data'
278 #### END DEBUG ####
279 [ -z "$nfsShares" ] && {
280 echo
281 echo "No NFS Shares mounted"
282 exit 1
283 }
284
285 local nfsCount=$(echo "$nfsShares" | wc -l)
286 count=1
287 while [ $count -le $nfsCount ];do
288 ((partitionCount++))
289 inputPartition[$partitionCount]=$(echo "$nfsShares" | sed -n ""$count"p")
290 NFS[$count]=$partitionCount
291 ((count++))
292 done
293 local num=1
294 selectedInputPartitionNumber=${NFS[$num]}
295 echo
296 }
297
298
299 function findImages(){
300 # <- folder to scan
301 #
302 # -> selectedInputImage - Number (index) in img array
303 # -> selectedInputImageSize - Size of disk / partition
304 # -> selectedInputImageID - Number - Partition ID (if user selected partition)
305 #
306 # -> imgCount - Number of images found
307 # -> partCount - Number of partitions found
308 #
309 # -> img - image name
310 # -> type - image type (partition/disk)
311 # -> activeItem - name of partition/disk
312 # -> imagePartitionSize - size of partition
313 # -> diskSizeFromImage - disk size
314 # -> partitionIdName - partition id in words
315 # -> id - description
316
317 if [ -z "$onlyImages" ];then
318 dialog --backtitle "$backTitle" --title " Working " --infobox "Searching for image files" 3 29
319 fi
320 imgCount=0
321 partCount=0
322
323 local count=1
324 local n
325 local tmp
326 local pCount
327 local tmpImg
328 local hasDisk=0
329 # set -x
330 for n in $(find "$1" -name parts 2>/dev/null);do
331 tmp="$(dirname "$n")"
332 if [ -z "$onlyImages" ];then
333 if [ "$(dirname "$tmp")" != "$1" ];then
334 continue
335 fi
336 fi
337 validateImage "$tmp" || continue
338 img[$count]="$(basename "$tmp")"
339
340 [ -r "$(dirname "$n")"/disk ] && {
341 # it's a disk image
342 hasDisk=1
343 type[$count]=disk
344 tmp="$(dirname "$n")"/disk
345 activeItem[$count]=$(cat "$tmp")
346 partCount=$(cat "$(dirname "$n")"/parts | awk '{print NF}')
347 tmp=$(dirname "$n")
348 diskSizeFromImage[$count]=$(getDiskSizeFromImage "$tmp")
349 id[$count]="Image: ${img[$count]}, ${type[$count]}: ${activeItem[$count]}"", size: ${diskSizeFromImage[$count]}, parts: $partCount"
350 # scan parts
351 pCount=1
352 tmpImg="${img[$count]}"
353 while [ $pCount -le $partCount ];do
354 ((count++))
355 img[$count]="$tmpImg"
356 type[$count]=part
357 activeItem[$count]=$(cat "$n" | awk '{for(i=1;i<=NF;i++) print $i}' | sed -n ""$pCount"p")
358 # set -x
359 calcInputSize "$tmp" "${activeItem[$count]}"
360 imagePartitionSize[$count]="$THIS_INPUT_SIZE"
361 partitionIdName[$count]=$(getPartitionIdNameFromImage /"$tmp" "${activeItem[$count]}")
362 ((pCount++))
363 id[$count]=" ${type[$count]}: ${activeItem[$count]}, size: ${imagePartitionSize[$count]}, type: ${partitionIdName[$count]}"
364 done
365 } || {
366 # it's a partition image
367 type[$count]=part
368 activeItem[$count]=$(cat "$n")
369 partCount=1
370 calcInputSize /"$tmp" "${activeItem[$count]}"
371 imagePartitionSize[$count]="$THIS_INPUT_SIZE"
372 partitionIdName[$count]=$(getPartitionIdNameFromImage /"$tmp" "${activeItem[$count]}")
373 id[$count]="Image: ${img[$count]}, ${type[$count]}: ${activeItem[$count]}, size: ${imagePartitionSize[$count]}, type: ${partitionIdName[$count]}"
374 }
375 imgCount="$count"
376 ((count++))
377 done
378 # exit
379 [ $imgCount -eq 0 ] &&{
380 local msgType
381 [ -z "${CD[$selectedInputPartitionNumber]}" ] && msgType=Partition || msgType=CD-ROM
382 if [ -n "$(echo "$selectedInputPartition" | grep '/')" ];then
383 msgType=Folder
384 selectedInputPartition=/"$selectedInputPartition"
385 fi
386 if [ -z "$onlyImages" ];then
387 dialog --backtitle "$backTitle" --title " No images found!!! " --msgbox "$msgType"" $selectedInputPartition contains no valid image files
388
389 Please try again selecting a different location" 7 60
390 else
391 echo "Error: $msgType $selectedInputPartition contains no valid image files!!!"
392 fi
393 cleanUP
394 exit 1
395 }
396 if [ -z "$onlyImages" ];then
397
398 local cmdLine=''
399
400 count=1
401 while [ $count -le $imgCount ];do
402 cmdLine="$cmdLine""$count"" \"""${id[$count]}""\" "
403 ((count++))
404 done
405
406 selectedInputImage=''
407
408 if [ $hasDisk -eq 1 ];then
409 local tit=" Partition/Disk to Restore "
410 local txt="Please select the partition/disk to restore"
411
412
413 # local msg="At least one of the images found contains a full disk backup
414 #
415 # Please use this image file to restore a full disk, ONLY in case the target disk is EXACTLY the same type as the original one (the disk that was backed up)
416 #
417 # In case the target disk is a different (bigger) one, you should NOT perform a full disk restore. Instead, exit this program, partition the target disk manually, in such a way that its partitions represent the partitions of the original disk, and then restore EACH partition seperatelly
418 #
419 # This way you will not have to resize the restored partitions on the target disk, after the entire restoration procedure has ended
420 #
421 # Do you want to continue?"
422 #
423 # dialog --backtitle "$backTitle" --title " Tips on disk restoration " --yesno "$msg" 20 72
424 #
425 # if [ $? -eq 1 ];then
426 # cleanUP
427 # exit
428 # fi
429
430 else
431 local tit=" Target Partition "
432 local txt="Please select the partition to restore"
433 fi
434
435 echo "dialog --backtitle \"$backTitle\" --title \""$tit"\" --menu \""$txt"\" $((imgCount+7)) 78 $imgCount $cmdLine" > /root/dialog.$$
436
437 . /root/dialog.$$ 2>/root/selectedImage.$$
438 selectedInputImage=$(cat /root/selectedImage.$$)
439 [ -z "$selectedInputImage" ] && {
440 cleanUP
441 exit
442 }
443
444 # set -x
445 # calculate image size and partition ID (if required)
446 if [ "${type[$selectedInputImage]}" = "part" ];then
447 calcInputSize /"$selectedInputPartition"/"${img[$selectedInputImage]}" "${activeItem[$selectedInputImage]}"
448 selectedInputImageSize="$THIS_INPUT_SIZE"
449 calcInputID /"$selectedInputPartition"/"${img[$selectedInputImage]}" "${activeItem[$selectedInputImage]}"
450 selectedInputImageID=$THIS_INPUT_ID
451 else
452 # calcInputSize /"$selectedInputPartition"/"${img[$selectedInputImage]}"
453 selectedInputImageSize="${diskSizeFromImage[$selectedInputImage]}"
454 fi
455 #
456 #
457 # cleanUP
458 # exit
459 else
460 echo "Image files found in: $selectedInputPartition"
461 count=1
462 until [ -z "${id[$count]}" ];do
463 echo " ${id[$count]}"
464 ((count++))
465 done
466 fi
467 }
468
469 function getPartitionIdNameFromImage(){
470 local id=$(grep "$2" "$1"/*pt.sf | sed 's|.*Id= *||' | sed 's|,.*$||')
471 sfdisk -T |sed 's|^[ ]||' | grep -e "^$id[ \t]" | sed "s|^$id *||"
472 }
473
474 function getDiskSizeFromImage(){
475 local lin=$(awk 'BEGIN{FS="="
476 count=0}
477 {if (count==0) b=$2
478 else{
479 b=b" * "
480 b=b$2
481 }
482 count++}
483 END{print b}' "$1"/*chs.sf | bc)
484 local size=$(echo "$lin * 512" | bc)
485 toMGByte "$size"
486 }
487
488 function getDiskSizeFromDisk(){
489 local size=$(fdisk -l /dev/"$1" | grep -e '^Disk /dev/' | sed 's|.*, *||' | sed 's| *bytes||')
490 toMGByte "$size"
491 }
492
493 function toMGByte(){
494 if [ $(expr length "$1") -le 9 ];then
495 echo $(expr substr "$1" 1 3 )"MB"
496 elif [ $(expr length "$1") -eq 10 ];then
497 echo $(expr substr "$1" 1 2 | sed 's|\([0-9]\)$|.\1|')"GB"
498 elif [ $(expr length "$1") -lt 12 ];then
499 echo $(expr substr "$1" 1 3 | sed 's|\([0-9]\)$|.\1|')"GB"
500 else
501 echo $(expr substr "$1" 1 4 | sed 's|\([0-9]\)$|.\1|')"GB"
502 fi
503 }
504
505 function validateImage(){
506 [ -d "$1"/parts ] && return 1
507 local sf=$(find "$1" -name "*-chs.sf" 2>/dev/null | wc -l)
508 [ $sf -eq 0 ] && return 1
509 local pt=$(find "$1" -name "*-pt.sf" 2>/dev/null | wc -l)
510 [ $pt -eq 0 ] && return 1
511 # modification to read unsplited images
512 # thanks to Viking (24/11/2008)
513 # local aa=$(find "$1" -name "*.aa" 2>/dev/null | wc -l)
514 # [ $aa -eq 0 ] && return 1
515 return 0
516 }
517
518 function cleanUP(){
519 if [ ! -z "$selectedInputPartition" ];then
520 [ -z "$workingRemote" ] && umount /"$selectedInputPartition" 2>/dev/null
521 fi
522 cd
523 rm /root/*.$$ 2>/dev/null
524 rm -rf /home/partimag/reloc-image
525 umount /home/partimag 2>/dev/null
526 # umount -a 2>/dev/null
527 [ -z "$onlyImages" ] && clear
528 }
529
530 function calcInputID(){
531 THIS_INPUT_ID=$(sed -n "/$2/p" "$1"/*-pt.sf | sed 's|.*Id= *||' | sed 's|,.*$||')
532 }
533
534 function calcInputSize(){
535 local bytesPerSector=512
536 local l
537 local pSize
538 local cylinders
539 local heads
540 local sectors
541 if [ -z "$2" ];then
542 cylinders=$(sed -n '/cylinders=/p' "$1"/*-chs.sf | sed 's|cylinders=||')
543 heads=$(sed -n '/heads=/p' "$1"/*-chs.sf | sed 's|heads=||')
544 sectors=$(sed -n '/sectors=/p' "$1"/*-chs.sf | sed 's|sectors=||')
545 THIS_INPUT_SIZE=$(echo "scale=2; $cylinders * $heads * $sectors * $bytesPerSector" | bc)
546 else
547 pSize=$(sed -n "/$2/p" "$1"/*-pt.sf | sed 's|.*size= *||' | sed 's|,.*||')
548 THIS_INPUT_SIZE=$(echo "scale=2; $pSize * $bytesPerSector" | bc)
549 fi
550
551 l=$(expr length $THIS_INPUT_SIZE)
552 if [ $l -gt 9 ];then
553 THIS_INPUT_SIZE=$(echo "scale=2; $THIS_INPUT_SIZE / 1024 / 1024 / 1024" | bc)GB
554 else
555 THIS_INPUT_SIZE=$(echo "scale=3; $THIS_INPUT_SIZE / 1024 / 1024" | bc | sed 's|\.000|.00|')MB
556 fi
557 }
558
559 function getPartitionSizeFromFdisk(){
560 local disk=$(echo "$1" | sed 's|[0-9]||')
561 if [ ! -e /root/closys-fdisk-"$disk".$$ ];then
562 fdisk -l /dev/"$disk" > /root/closys-fdisk-"$disk".$$
563 fi
564 local size=$(sed 's|*||' /root/closys-fdisk-"$disk".$$ | grep "$1" | awk '{print $4}' | sed 's|[+-]||')
565 local gB=$(echo "scale=2; $size / 1024 / 1024 " | bc | sed 's|^\.|0.|')GB
566 local mB=$(echo "scale=2; $size / 1024 " | bc)MB
567 if [ -z $(echo "$gB" | grep -e '^[0]') ];then
568 THIS_PARTITION_SIZE="$gB"
569 else
570 THIS_PARTITION_SIZE="$mB"
571 fi
572 }
573
574 function getOutputPartition(){
575 ## select target partition
576 dialog --backtitle "$backTitle" --title " Working " --infobox "Searching for valid partitions" 3 34
577 local count=1
578 local cmdLine=''
579 local outputPartitionCount=0
580 local tmpDisk
581 local tmpID
582 local fatpartitions=''
583 local compResult
584 until [ -z "${inputPartition[$count]}" ];do
585 if [ "${inputPartition[$count]}" != "$selectedInputPartition" ] && [ -z "${CD[$count]}" ];then
586 tmpDisk=$(echo "${inputPartition[$count]}" | sed 's|[0-9]||')
587 tmpID=$(fdisk -l /dev/"$tmpDisk" 2>/dev/null| grep "${inputPartition[$count]}" | sed 's|*||' | awk '{print $5}')
588 if [ "$tmpID" = "$selectedInputImageID" ];then
589 comparePartitionsSize "$selectedInputImageSize" "${partitionSize[$count]}"
590 compResult=$?
591 if [ $compResult -eq 0 ];then
592 cmdLine="$cmdLine""${inputPartition[$count]}"" ""\"Size: ${partitionSize[$count]}, Type: ${partitionType[$count]} (identical part)\""" "
593 ((outputPartitionCount++))
594 elif [ $compResult -eq 2 ];then
595 cmdLine="$cmdLine""${inputPartition[$count]}"" ""\"Size: ${partitionSize[$count]}, Type: ${partitionType[$count]}\""" "
596 ((outputPartitionCount++))
597 needsResize[$count]='-r'
598 # echo "count = $count"
599 fi
600 fi
601 if [ "$tmpID" = "b" ] && [ "$selectedInputImageID" = "6" ];then
602 comparePartitionsSize "$selectedInputImageSize" "${partitionSize[$count]}"
603 compResult=$?
604 if [ $compResult -eq 0 ];then
605 cmdLine="$cmdLine""${inputPartition[$count]}"" ""\"Size: ${partitionSize[$count]}, Type: ${partitionType[$count]} (identical part)\""" "
606 ((outputPartitionCount++))
607 elif [ $compResult -eq 2 ];then
608 cmdLine="$cmdLine""${inputPartition[$count]}"" ""\"Size: ${partitionSize[$count]}, Type: ${partitionType[$count]}\""" "
609 ((outputPartitionCount++))
610 needsResize[$count]='-r'
611 # echo "count = $count"
612 fi
613 fi
614 if [ "$tmpID" = "c" ] && [ "$selectedInputImageID" = "6" ];then
615 comparePartitionsSize "$selectedInputImageSize" "${partitionSize[$count]}"
616 compResult=$?
617 if [ $compResult -eq 0 ];then
618 cmdLine="$cmdLine""${inputPartition[$count]}"" ""\"Size: ${partitionSize[$count]}, Type: ${partitionType[$count]} (identical part)\""" "
619 ((outputPartitionCount++))
620 elif [ $compResult -eq 2 ];then
621 cmdLine="$cmdLine""${inputPartition[$count]}"" ""\"Size: ${partitionSize[$count]}, Type: ${partitionType[$count]}\""" "
622 ((outputPartitionCount++))
623 needsResize[$count]='-r'
624 # echo "count = $count"
625 fi
626 fi
627 fi
628 ((count++))
629 done
630
631 if [ $outputPartitionCount -eq 0 ];then
632 dialog --backtitle "$backTitle" --title " No available partitions!!! " --msgbox "The program found no valid partitions for restoration!!!
633
634 The selected (backed up) partition size is $selectedInputImageSize, type ${partitionIdName[$selectedInputImage]}, but none of the partitions found on your disks are either this big or of this type
635
636 This means that you should repartition one of your disks and create a partition with size at least $selectedInputImageSize and type ${partitionIdName[$selectedInputImage]}" 12 70
637 cleanUP
638 exit
639 fi
640
641 # cleanUP
642 # exit
643 tmpPartName=$(sfdisk -T | sed 's|^[ \t]||' | grep -e "^"$selectedInputImageID" " | sed "s|^"$selectedInputImageID"[ /t]*||" | sed 's|,.*$||')
644 if [ $outputPartitionCount -gt 0 ];then
645
646 # chech partitions size
647 local thisHeight=$outputPartitionCount
648 local totHeigh=$((outputPartitionCount+8))
649 if [ $totHeigh -gt 20 ];then
650 totHeigh=20
651 thisHeight=$(totHeigh-8)
652 fi
653 echo "dialog --backtitle \"$backTitle\" --title \" Target Partition \" --menu \"Please select the partition where your image file will be restored
654 Original image type: $tmpPartName, size: $selectedInputImageSize\" $totHeigh 78 $thisHeight $cmdLine" > /root/dialog.$$
655
656 . /root/dialog.$$ 2>/root/outputPartition.$$
657 selectedOutputPartition=$(cat /root/outputPartition.$$)
658 [ -z "$selectedOutputPartition" ] && {
659 cleanUP
660 exit
661 }
662 else
663 dialog --backtitle "$backTitle" --title " No available partitions!!! " --msgbox "The program found no valid partitions for restoration!!!
664
665 The selected (backed up) partition type is $tmpPartName (ID = $selectedInputImageID), but none of the partitions found on your disks are of this type
666
667 This means that you should repartition one of your disks and create a $tmpPartName partition with ID $selectedInputImageID, or change an existing ID to $selectedInputImageID" 12 70
668 cleanUP
669 exit 1
670 fi
671 # set -x
672 count=1
673 until [ -z "${inputPartition[$count]}" ];do
674 if [ "${inputPartition[$count]}" = "$selectedOutputPartition" ];then
675 selectedOutputPartitionIndex=$count
676 break
677 fi
678 ((count++))
679 done
680 set +x
681
682 }
683
684 function comparePartitionsSize(){
685 #
686 # partition size format: xxxx.x[kMG]B
687 #
688 # <- $1 $2 - the sizes
689 #
690 # -> 0 - equal
691 # -> 1 - $1 > $2
692 # -> 2 - $2 > $1
693 # set -x
694 if [ "$1" = "$2" ];then return 0;fi
695 local count=1
696 while [ $count -le 2 ];do
697 local size[$count]=$(echo "$1" | sed 's|[kMG]B||')
698 # echo "size[$count] = ${size[$count]}"
699 local factor[$count]=$(echo "$1" | sed 's|.*\([kMG]\)B|\1|')
700 # echo "factor[$count] = ${factor[$count]}"
701 getMultiplier ${factor[$count]}
702 local multiplier[$count]=$THIS_MULTIPLIER
703 # echo "multiplier[$count] = ${multiplier[$count]}"
704 shift
705 ((count++))
706 done
707 return $(echo "a=${size[1]} * ${multiplier[1]};
708 b=${size[2]} * ${multiplier[2]};
709 if (a==b) print 0
710 if (a>b) print 1
711 if (a<b) print 2" | bc)
712 }
713
714 function getMultiplier(){
715 # echo $#
716 case "$1" in
717 k) THIS_MULTIPLIER=1024;;
718 M) THIS_MULTIPLIER=1048576;;
719 G) THIS_MULTIPLIER=1073741824;;
720 esac
721 }
722
723 function getRestoreParameters(){
724 # used only in disk restore, when disks not equal
725 # # Get restore parameters
726 dialog --separate-output --backtitle "$backTitle" --title " Restore options " --checklist "Please select your restore options" 10 78 3 "-k" "Keep target disk partition table (do not re-partition)" on "-r" "Resize partitions on target disk to maximum size" on "-t" "Do not write the MBR to the target disk" off 2>/root/params.$$
727 if [ $? -ne 0 ];then
728 cleanUP
729 exit
730 fi
731 count=1
732 while [ $count -le 3 ];do
733 param[$count]=$(sed -n ""$count"p" /root/params.$$ | sed 's/[ ]*//' )
734 ((count++))
735 done
736 }
737
738 function preparePartitionImage(){
739 dialog --backtitle "$backTitle" --title " Working " --infobox "Preparing temporary image file" 3 34
740 if [ -d /home/partimag ];then
741 umount /home/partimag 2>/dev/null
742 rm -rf /home/partimag/* 2>/dev/null
743 else
744 rm -rf /home/partimag 2>/dev/null
745 mkdir /home/partimag
746 fi
747 rm -rf /home/partimag/reloc-image 2>/dev/null
748 mkdir /home/partimag/reloc-image
749 # echo /"$selectedInputPartition"/"${img[$selectedInputImage]}"
750 local inTmpDisk=$(echo "${activeItem[$selectedInputImage]}" | sed 's|[0-9]||')
751 local outTmpDisk=$(echo "$selectedOutputPartition" | sed 's|[0-9]||')
752 local outTmpPartition=$(echo "$selectedOutputPartition" | sed 's|[a-z]*||')
753 local tmpFile
754 local outFile
755 local count
756 #set -x
757 for n in $(find /"$selectedInputPartition"/"${img[$selectedInputImage]}" -name "*");do
758 tmpFile=$(basename "$n")
759 if [ "$tmpFile" != "${img[$selectedInputImage]}" ];then
760 # echo "$tmpFile"
761 outFile=$(echo "$tmpFile" | sed "s|${activeItem[$selectedInputImage]}|$selectedOutputPartition|" |sed "s|$inTmpDisk|$outTmpDisk|")
762 # echo "${activeItem[$selectedInputImage]} => $selectedOutputPartition"
763 # echo ln -s "$n" /home/partimag/reloc-image/"$outFile"
764 ln -s "$n" /home/partimag/reloc-image/"$outFile"
765 fi
766 done
767 if [ "${activeItem[$selectedInputImage]}" != "$selectedOutputPartition" ];then
768 [ -e /home/partimag/reloc-image/disk ] && {
769 rm /home/partimag/reloc-image/disk
770 echo "$outTmpDisk" > /home/partimag/reloc-image/disk
771 }
772 sed "s|${activeItem[$selectedInputImage]}|$selectedOutputPartition|" /home/partimag/reloc-image/parts | sed "s|$inTmpDisk|$outTmpDisk|" > /home/partimag/reloc-image/parts.tmp
773 rm /home/partimag/reloc-image/parts
774 mv /home/partimag/reloc-image/parts.tmp /home/partimag/reloc-image/parts
775 rm /home/partimag/reloc-image/"$outTmpDisk"-pt.sf
776 echo "# partition table of /dev/"$outTmpDisk"" > /home/partimag/reloc-image/"$outTmpDisk"-pt.sf
777 echo "unit: sectors" >> /home/partimag/reloc-image/"$outTmpDisk"-pt.sf
778 echo >> /home/partimag/reloc-image/"$outTmpDisk"-pt.sf
779 count=1
780 while [ $count -lt $outTmpPartition ];do
781 echo "/dev/"$outTmpDisk""$count" : start= 0, size= 0, Id= 0" >> /home/partimag/reloc-image/"$outTmpDisk"-pt.sf.tmp
782 ((count++))
783 done
784 grep "${activeItem[$selectedInputImage]}" /home/partimag/reloc-image/"$outTmpDisk"-pt.sf | sed "s|${activeItem[$selectedInputImage]}|$selectedOutputPartition|" >> /home/partimag/reloc-image/"$outTmpDisk"-pt.sf.tmp
785 rm /home/partimag/reloc-image/"$outTmpDisk"-pt.sf
786 mv /home/partimag/reloc-image/"$outTmpDisk"-pt.sf.tmp /home/partimag/reloc-image/"$outTmpDisk"-pt.sf
787 fi
788 }
789
790 function doPartitionRestore(){
791 # set -x
792 if [ -z "${needsResize[$selectedOutputPartitionIndex]}" ];then
793 msg="The temporary image file is now ready, and you are about to start the Restore operation
794
795 Are you sure you want to restore
796 the backup of partition ${activeItem[$selectedInputImage]}
797 to
798 partition $selectedOutputPartition?"
799 else
800 msg="The temporary image file is now ready, and you are about to start the Restore operation
801
802 Are you sure you want to restore and resize
803 the backup of partition ${activeItem[$selectedInputImage]}
804 to
805 partition $selectedOutputPartition?"
806 fi
807 dialog --backtitle "$backTitle" --title "Ready to Restore" --yesno "$msg" 11 70
808
809 if [ $? -eq 0 ];then
810 # Do restore
811 COMMAND="ocs-sr -p true -k -t "${needsResize[$selectedOutputPartitionIndex]}" -b restoreparts reloc-image $selectedOutputPartition"
812 fi
813 }
814
815 function getOutputDisk(){
816 #
817 # -> diskGeometry - system disk geometry (array)
818 # item empty if disk smaller than image
819 # or not same number of partitions
820 # or partitions not same type
821 # -> equalDisk - denotes an equal disk geometry (array)
822 # item ont empty if disk is equal to image disk
823 # -> diskToRestoreCount - Number of available disks to restore
824 local cmdLine
825 diskToRestoreCount=0
826 getDiskGeometry
827 selectedImageDiskGeometry=$THIS_GEOMETRY
828
829 local count=1
830 local mountedDisk=$(echo "$selectedInputPartition" | sed 's|[0-9]||')
831 # set -x
832 while [ $count -le $diskCount ];do
833 if [ "${inputDisk[$count]}" != "$mountedDisk" ];then
834 getDiskGeometry /dev/"${inputDisk[$count]}"
835 if [ "$THIS_GEOMETRY" = "$selectedImageDiskGeometry" ];then
836 # we have two identical disks
837 diskGeometry[$count]="$THIS_GEOMETRY"
838 equalDisk[$count]=1
839 ((diskToRestoreCount++))
840 cmdLine="$cmdLine""\"""${inputDisk[$count]}""\""" ""\"""Size: $(getDiskSizeFromDisk ${inputDisk[$count]}) (identical disk)""\" "
841 else
842 # disks are different
843 local selGeo=$(echo "$selectedImageDiskGeometry" |sed 's|,|*|g')
844 local thisGeo=$(echo "$THIS_GEOMETRY" |sed 's|,|*|g')
845 local compResult=$(echo "a=$selGeo;
846 b=$thisGeo;
847 if (a==b) print 0
848 if (a>b) print 1
849 if (a<b) print 2" | bc)
850 if [ $compResult -eq 2 ];then
851 # disk is large enough
852 # do we have same number of partitions and same type?
853 compResult=$(checkDisksPartitions)
854 if [ $compResult -eq 0 ];then
855 diskGeometry[$count]="$THIS_GEOMETRY"
856 ((diskToRestoreCount++))
857 cmdLine="$cmdLine""\"""${inputDisk[$count]}""\""" ""\"""Size: $(getDiskSizeFromDisk ${inputDisk[$count]})""\" "
858 fi
859 fi
860 fi
861
862 fi
863 ((count++))
864 done
865 if [ $diskToRestoreCount -eq 0 ];then
866 dialog --backtitle "$backTitle" --title " No disks found!!! " --msgbox "Your system has no valid disks to restore this image file!!!
867
868 In order to perform a disk restoration, you must have:
869
870 a. A disk with the same geometry as the source disk
871 In this case you will perform a full disk restore, creating
872 partitions and restoring the MBR, or
873
874 b. A prepartitioned larger disk which contains exactly the same
875 partitions as the source disk (same partition number and id)
876 In this case no partition creation will take place, but the
877 target partitions will be resized to maximum size" 16 70
878 cleanUP
879 exit
880 fi
881
882 # make dialog
883 echo "dialog --backtitle \"$backTitle\" --title \" Target Disk \" --menu \"Please select the disk where your image file will be restored
884 Original image: ${img[$selectedInputImage]}, disk: ${activeItem[$selectedInputImage]}, size: $selectedInputImageSize\" $((diskToRestoreCount+8)) 78 $diskToRestoreCount $cmdLine" > /root/dialog.$$
885
886 . /root/dialog.$$ 2>/root/selectedDisk.$$
887 selectedOutputDisk=$(cat /root/selectedDisk.$$)
888
889 [ -z "$selectedOutputDisk" ] && {
890 cleanUP
891 exit
892 }
893
894
895 }
896
897 function getDiskGeometry(){
898 if [ -z "$1" ];then
899 # get image disk geometry
900 THIS_GEOMETRY=$(awk 'BEGIN{FS="="
901 count=0}
902 {if (count==0) b=$2
903 else{
904 b=b","
905 b=b$2
906 }
907 count++}
908 END{print b}' /"$selectedInputPartition"/"${img[$selectedInputImage]}"/*-chs.sf)
909 else
910 # get disk geometry
911 THIS_GEOMETRY=$(sfdisk -g "$1" | sed 's|^.*:||' | sed 's|cylinders||' | sed 's|heads||' | sed 's|sectors/track||' | sed 's| *||g')
912 fi
913
914 }
915
916 function checkDisksPartitions(){
917 local imgData=$(grep -e '^/dev/' /"$selectedInputPartition"/"${img[$selectedInputImage]}"/*-pt.sf | sed 's| : .*Id= *|:|')
918
919 local diskData=$(sfdisk -l /dev/${inputDisk[$count]} 2>/dev/null| grep -e '^/dev/' | awk '{
920 if ($2=="*")
921 print $1 ":" $7 ", bootable"
922 else
923 print $1 ":" $6}' | sed "s|${inputDisk[$count]}|${activeItem[$selectedInputImage]}|")
924
925 if [ "$imgData" != "$diskData" ];then
926 echo 1
927 return
928 fi
929
930 # check partitions size
931 local numOfPartitions=$(grep 'size=' /"$selectedInputPartition"/"${img[$selectedInputImage]}"/*-pt.sf | wc -l)
932 local imgPartitionSize
933 local diskPartitionSize
934 local partCount=1
935
936 sfdisk -d /dev/${inputDisk[$count]} > /root/disk-${inputDisk[$count]}.$$
937 while [ $partCount -le $numOfPartitions ];do
938 imgPartitionSize=$(grep 'size=' /"$selectedInputPartition"/"${img[$selectedInputImage]}"/*-pt.sf | sed -n ""$partCount"p"| sed 's|.*size= *||' | sed 's|,.*$||' | sed 's|[+-]||')
939 diskPartitionSize=$(grep 'size=' /root/disk-${inputDisk[$count]}.$$ | sed -n ""$partCount"p"| sed 's|.*size= *||' | sed 's|,.*$||' | sed 's|[+-]||')
940 local compResult=$(echo "a=$imgPartitionSize;
941 b=$diskPartitionSize;
942 if (a==b) print 0
943 if (a>b) print 1
944 if (a<b) print 2" | bc)
945 if [ $compResult -eq 2 ];then
946 echo 1
947 return
948 fi
949 ((partCount++))
950 done
951 echo 0
952 }
953
954
955
956 function prepareDiskImage(){
957 dialog --backtitle "$backTitle" --title " Working " --infobox "Preparing temporary image file" 3 34
958 if [ -d /home/partimag ];then
959 umount /home/partimag 2>/dev/null
960 rm -rf /home/partimag/* 2>/dev/null
961 else
962 rm -rf /home/partimag 2>/dev/null
963 mkdir /home/partimag
964 fi
965 rm -rf /home/partimag/reloc-image 2>/dev/null
966 mkdir /home/partimag/reloc-image
967
968 # count is not local, will be used in doDiskRestore
969 count=1
970 until [ -z "${inputDisk[$count]}" ];do
971 # if [ "${activeItem[$count]}" = "$selectedOutputDisk" ];then
972 if [ "${inputDisk[$count]}" = "$selectedOutputDisk" ];then
973 break
974 fi
975 ((count++))
976 done
977
978 local tmpFile
979 for n in $(find /"$selectedInputPartition"/"${img[$selectedInputImage]}" -name "*");do
980 tmpFile=$(basename "$n")
981 if [ "$tmpFile" != "${img[$selectedInputImage]}" ];then
982 outFile=$(echo "$tmpFile" |sed "s|${activeItem[$selectedInputImage]}|$selectedOutputDisk|")
983 ln -s "$n" /home/partimag/reloc-image/"$outFile"
984 fi
985 done
986
987 if [ "${activeItem[$selectedInputImage]}" != "$selectedOutputDisk" ];then
988 rm /home/partimag/reloc-image/disk
989 echo "$selectedOutputDisk" > /home/partimag/reloc-image/disk
990 rm /home/partimag/reloc-image/parts
991 echo "$(cat /"$selectedInputPartition"/"${img[$selectedInputImage]}"/parts | sed "s|${activeItem[$selectedInputImage]}|$selectedOutputDisk|")" > /home/partimag/reloc-image/parts
992 rm /home/partimag/reloc-image/"$selectedOutputDisk"-pt.sf
993 sfdisk -d /dev/"$selectedOutputDisk" > /home/partimag/reloc-image/"$selectedOutputDisk"-pt.sf
994 if [ -z "${equalDisk[$count]}" ];then
995 rm /home/partimag/reloc-image/"$selectedOutputDisk"-chs.sf
996 sfdisk -d /dev/"$selectedOutputDisk" > /home/partimag/reloc-image/"$selectedOutputDisk"-chs.sf
997 fi
998 fi
999 }
1000
1001 function doDiskRestore(){
1002 if [ -z "${equalDisk[$count]}" ];then
1003 getRestoreParameters
1004 # disks not equal, do resize, restore MBR, don't create partitions
1005
1006 msg="The temporary image file is now ready, and you are about to start the Restore operation
1007
1008 You are about to restore
1009 the backup of disk ${activeItem[$selectedInputImage]}
1010 to
1011 disk $selectedOutputDisk
1012
1013 Info: The target disk is larger than the backed up disk
1014 Selected Restore options will be be applied
1015
1016 Do you want to continue?"
1017 dialog --backtitle "$backTitle" --title "Ready to Restore" --yesno "$msg" 16 70
1018
1019 if [ $? -eq 0 ];then
1020 # Do restore
1021 COMMAND="ocs-sr -p true -e -b "${param[1]}" "${param[2]}" "${param[3]}" restoredisk reloc-image $selectedOutputDisk"
1022 fi
1023 else
1024 # disks are equal, restore MBR, do partitioning, no resize
1025 msg="The temporary image file is now ready, and you are about to start the Restore operation
1026
1027 You are about to restore
1028 the backup of disk ${activeItem[$selectedInputImage]}
1029 to
1030 disk $selectedOutputDisk
1031
1032 Info: The disks are identical, so the target disk will be
1033 partitioned and the MBR will be restored
1034
1035 Do you want to continue?"
1036 dialog --backtitle "$backTitle" --title "Ready to Restore" --yesno "$msg" 16 70
1037
1038 if [ $? -eq 0 ];then
1039 # Do restore
1040 COMMAND="ocs-sr -p true -e -b restoredisk reloc-image $selectedOutputDisk"
1041 fi
1042 fi
1043 }
1044
1045 function testRoot(){
1046 if [ "$(whoami)" != "root" ];then
1047 printVersion
1048 echo "Error: This script must be executed by root..."
1049 exit
1050 fi
1051 }
1052
1053 function printVersion(){
1054 echo "Clonezilla Live Image Restoration with Relocation
1055 $(basename $0) v. $versionNumber - (C) 2007-2008 S. Georgaras <sng@hellug.gr>
1056 "
1057 }
1058
1059 function printHelp(){
1060 printVersion
1061 echo "Usage: $(basename $0) <options>
1062
1063 Available options:
1064 i [location] Print info about Clonezilla Live Image files found in [location]
1065 [location] may be a hard disk partition, a CD-ROM device name or
1066 smb - the first Samba Share
1067 nfs - the first NFS Share
1068 Remote shares must be mounted beforehand
1069 v Print version info and exit
1070 h Print this screen and exit"
1071 }
1072
1073 #
1074 #
1075 # Script starts here
1076 #
1077 #
1078
1079 # findDirectories /home/spiros/multibootcd/files
1080 # #findDirectories /home/partimag
1081 #
1082 # exit
1083
1084
1085 #toMGByte "$1"
1086 #exit
1087
1088
1089
1090
1091 # grep -e '^/dev/' /data/test-img/hda-pt.sf | sed 's| : .*Id= *|:|'
1092 #
1093 #
1094 # sfdisk -l /dev/hda 2>/dev/null| grep -e '^/dev/' | awk '{
1095 # if ($2=="*")
1096 # print $1 ":" $7 ", bootable"
1097 # else
1098 # print $1 ":" $6}'
1099 # exit
1100
1101
1102 # getPartitionIdNameFromImage /data/usb250-img sda4
1103 # exit
1104
1105 # set -x
1106 # getDiskSizeFromImage /data/usb250-img
1107 # exit
1108
1109 # echo "$partitionList"
1110 # exit
1111
1112 # getMultiplier M f g
1113 # echo "$THIS_MULTIPLIER"
1114
1115 # set -x
1116 # comparePartitionsSize 2GB 2GB
1117 # echo $?
1118 # exit
1119 # set -x
1120 # getPartitionSizeFromFdisk hda1
1121 # echo "$THIS_PARTITION_SIZE"
1122 # exit
1123
1124
1125 # mountedInputPartition=/data
1126 # # set -x
1127 # findImages "$mountedInputPartition"
1128
1129 # set -x
1130 # count=1
1131 # until [ -z "${img[$count]}" ];do
1132 # echo "${id[$count]}"
1133 # ((count++))
1134 # done
1135 #
1136 # exit
1137
1138
1139 # calcInputSize /data/usb250-img
1140 # calcInputSize /data/usb250-img sda4
1141 # calcInputID /data/usb250-img sda4
1142 # exit
1143
1144 while getopts hvi: opt
1145 do
1146 case "$opt" in
1147 i)
1148 onlyImages=true
1149 diskToScan=$(echo "$OPTARG" | sed 's|^/dev/||')
1150 ;;
1151 v)
1152 printVersion
1153 exit;;
1154 h)
1155 printHelp
1156 exit;;
1157 esac
1158 done
1159 shift $(( OPTIND - 1 ))
1160
1161 testRoot
1162 backTitle="Clonezilla Live Image Restoration with Relocation"
1163
1164 for CHK_DIR in /home/partimag /tmp/local-dev;do
1165 CHK_HOME_PARTIMAG="$(mount | grep "$CHK_DIR")"
1166 if [ -n "$CHK_HOME_PARTIMAG" ];then
1167 CHK_MSG="
1168 A local partition or shared folder is already mounted
1169 under "$CHK_DIR". reloc-img will now terminate to
1170 prevent loss of data
1171
1172 Please unmount it and try again"
1173 CHK_TITLE=" "$CHK_DIR" already mounted!!! "
1174
1175 if [ -z "$onlyImages" ];then
1176
1177 dialog --backtitle "$backTitle" --title "$CHK_TITLE" --msgbox "$CHK_MSG" 10 66
1178 else
1179 echo "$CHK_MSG"
1180 echo
1181 fi
1182 # Don't use cleanUP here, we want user to see the mounted partition
1183 # cleanUP
1184 exit
1185 fi
1186 done
1187
1188
1189 trap cleanUP 2
1190
1191 if [ ! -z "$onlyImages" ];then
1192 printVersion
1193
1194
1195 if [ "$diskToScan" = "smb" ];then
1196 # if [ $(mount |grep cifs | wc -l) -eq 0 ];then
1197 # echo "Error: No Samba Share mounted!!!"
1198 # cleanUP
1199 # exit
1200 # fi
1201 # set -x
1202 selectedInputPartition=smb1
1203 workingRemote='y'
1204 findSambaShare
1205 elif [ "$diskToScan" = "nfs" ];then
1206 if [ $(mount |grep nfs | wc -l) -eq 0 ];then
1207 echo "Error: No NFS Share mounted!!!"
1208 cleanUP
1209 exit
1210 fi
1211 selectedInputPartition=nfs1
1212 workingRemote='y'
1213 findNFSShare
1214 else
1215 test1=$(cat /proc/partitions | grep "$diskToScan")
1216 if [ -z "$test1" ];then
1217 # It is not a disk partition
1218 # Is it a CD-ROM?
1219 test1=$(cat /proc/sys/dev/cdrom/info | grep 'drive name' |sed 's|drive name:[ \t]*||' | awk '{for(i=1;i<=NF;i++) print $i}' | grep "$diskToScan")
1220 if [ -z "$test1" ];then
1221 echo "Error: No such partition or CD-ROM: $diskToScan"
1222 cleanUP
1223 exit
1224 fi
1225 fi
1226 selectedInputPartition="$diskToScan"
1227 fi
1228 else
1229
1230
1231
1232
1233 msg="This program is part of Clonezilla-SysRescCD, and is provided with the hope that it will be error-free and useful. If you have found a bug, or the program does not behave as expected, please report it to
1234 Spiros Georgaras <sng@hellug.gr>
1235
1236 It will help you restore a Clonezilla Image file to a disk/partition different from the one originally backed up.
1237
1238 For example, you will be able to restore your backed up hdb disk to a (new) disk, hdc, or your backed up hda4 partition to a (new) partition, hdb3.
1239
1240 The target disk/partition must be the same partition type and at least equal (size-wise) to the old - backed up - disk/partition
1241
1242 Please make sure all removable devices are connected to the system before pressing OK, and that no local partition is mounted
1243
1244 All data in the target disk/partition will be OVERWRITTEN!!!
1245
1246 ----------------------
1247 THIS SOFTWARE COMES WITH ABSOLUTELY NO WARRANTY!
1248 USE AT YOUR OWN RISK!
1249 ----------------------"
1250
1251 msg1="Do you want to continue?"
1252 dialog --backtitle "$backTitle" --title " Wellcome " \
1253 --msgbox "$msg" 20 72 \
1254 --and-widget --yesno "$msg1" 5 45 || {
1255 clear
1256 exit
1257 }
1258
1259 dialog --backtitle "$backTitle" --title " Working " --infobox "Determining system disks and partitions" 3 43
1260
1261 findSystemPartitions
1262 # mount selectedInputPartition
1263 dialog --backtitle "$backTitle" --title " Working " --infobox "Mounting selected device" 3 28
1264
1265 fi
1266
1267
1268
1269
1270 [ -z "$selectedInputPartition" ] && {
1271 cleanUP
1272 echo "Error: selectedInputPartition is empty!!!"
1273 exit 1
1274 }
1275 # set -x
1276 if [ -z "$workingRemote" ];then
1277 # mount partition
1278 mkdir /"$selectedInputPartition" 2>/dev/null
1279 [ -d /"$selectedInputPartition" ] || {
1280 cleanUP
1281 echo "Error: Could not create folder: /$selectedInputPartition"
1282 exit 1
1283 }
1284 #set -x
1285 if [ -z "$DEBUG" ];then
1286 mkdir /"$selectedInputPartition" 2>/dev/null
1287 if [ -z "${CD[$selectedInputPartitionNumber]}" ];then
1288 # This is a disk partition
1289 mount /dev/"$selectedInputPartition" /"$selectedInputPartition" 2>/dev/null
1290 mountResult=$?
1291 else
1292 # This is a CD
1293 # Is it mounted?
1294 rm /home/partimag 2>/dev/null
1295 mkdir /home/partimag 2>/dev/null
1296 if [ -z "$(mount | grep "/dev/$selectedInputPartition")" ];then
1297 # No it's not, mount it
1298 echo "mount /dev/\"$selectedInputPartition\" /\"$selectedInputPartition\"" > /root/mountCommand.$$
1299 . /root/mountCommand.$$ && mountResult=0 || mountResult=1
1300 else
1301 # Yes it is ,mount through bind
1302 bindDir=$(mount | grep "/dev/$selectedInputPartition" | sed 's|.* on ||' | sed 's| type.*||')
1303 # echo "mount --bind \"$bindDir\" /\"$selectedInputPartition\" 2>/dev/null" > /root/mountCommand.$$
1304
1305
1306 if [ -d "$bindDir"/home/partimag ]; then bindDir="$bindDir"/home/partimag;fi
1307
1308 echo "mount --bind \"$bindDir\" /\"$selectedInputPartition\" 2>/dev/null" > /root/mountCommand.$$
1309
1310
1311
1312 chmod +x /root/mountCommand.$$
1313 . /root/mountCommand.$$ && mountResult=0 || mountResult=1
1314 fi
1315 fi
1316 else
1317 ### start DEBUG section
1318 mount --bind /data /"$selectedInputPartition"
1319 mountResult=$?
1320 ### end DEBUG section
1321 fi
1322 #read
1323
1324 # Chech mounting result
1325 if [ $mountResult -ne 0 ];then
1326 if [ -z "$onlyImages" ];then
1327 if [ -z "${CD[$selectedInputPartitionNumber]}" ];then
1328 dialog --backtitle "$backTitle" --title " Mount error!!! " --msgbox "Partition $selectedInputPartition could not be mounted
1329
1330 Please unmount all local partitions, and try again" 7 70
1331 cleanUP
1332 exit 1
1333 else
1334 while [ $mountResult -ne 0 ];do
1335 dialog --backtitle "$backTitle" --title " Mount error!!! " --yesno "CD-ROM $selectedInputPartition could not be mounted. This may be caused because you did not load the disk in the CD-ROM drive. Make sure the disk is in the drive and press Yes
1336
1337 Do you want to try again?" 9 70
1338 if [ $? -eq 0 ];then
1339 dialog --backtitle "$backTitle" --title " Working " --infobox "Mounting selected device" 3 28
1340 . /root/mountCommand.$$ && mountResult=0 || mountResult=1
1341 else
1342 cleanUP
1343 exit 1
1344 fi
1345 done
1346 fi
1347 else
1348 echo "Error: Could not mount $selectedInputPartition"
1349 cleanUP
1350 exit 1
1351 fi
1352
1353 fi
1354 else
1355 selectedInputPartition=$(echo "${inputPartition[$selectedInputPartitionNumber]}" | sed 's|^/||')
1356 fi
1357
1358
1359 ########################################################
1360 #
1361 # find directories...
1362 #
1363 ########################################################
1364 if [ -z "$onlyImages" ];then
1365 findDirectories /"$selectedInputPartition"
1366 if [ -z "$activeDirectory" ];then
1367 cleanUP
1368 exit
1369 fi
1370
1371 if [ "$activeDirectory" != "/" ];then
1372 selectedInputPartition="$selectedInputPartition"/"$activeDirectory"
1373 fi
1374 fi
1375 ########################################################
1376
1377
1378 findImages /"$selectedInputPartition"
1379
1380 if [ ! -z "$onlyImages" ];then
1381 cleanUP
1382 exit
1383 fi
1384
1385
1386 if [ "${type[$selectedInputImage]}" = "part" ];then
1387 getOutputPartition
1388 preparePartitionImage
1389 doPartitionRestore
1390 else
1391 getOutputDisk
1392 prepareDiskImage
1393 doDiskRestore
1394 fi
1395 # checking=aaa
1396 if [ ! -z "$COMMAND" ];then
1397 if [ -z "$checking" ];then
1398 $COMMAND
1399 else
1400 echo "The command that would be executed is:
1401 $COMMAND"
1402 # read
1403 fi
1404 fi
1405 cleanUP

Properties

Name Value
svn:executable *

webmaster@linux.gr
ViewVC Help
Powered by ViewVC 1.1.26