1 |
sng |
47 |
#!/bin/bash |
2 |
sng |
48 |
############################################################################## |
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 |
sng |
47 |
# 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 |