1 #!/bin/bash

2 #

12 # ##

29 function ogCreateImageSyntax()

30 {

31 local FS TOOL LEVEL DEV IMGFILE BUFFER PARAM1 PARAM2 PARAM3

32 

33 # Si se solicita, mostrar ayuda.

34 if [ "$*" == "help" ]; then

35  ogHelp "$FUNCNAME" "$FUNCNAME path_device path_imagefile [str_tool] [str_compressionlevel]" \

36  "$FUNCNAME /dev/sda1 /opt/opengnsys/images/prueba.img partclone lzop" \

37  "$FUNCNAME /dev/sda1 /opt/opengnsys/images/prueba.img"

38  return

39 fi

40 # Error si no se reciben entre 2 y 4 parámetros.

41 [ $# -ge 2 -a $# -le 4 ] || ogRaiseError $OG_ERR_FORMAT "$*" || return $?

42 

43 # Asignación de parámetros.

44 DEV="$1"

45 IMGFILE="$2"

46 case "$#" in

47  2) # Sintaxis por defecto OG DEV IMGFILE

48  TOOL="partclone"

49  LEVEL="gzip"

50  ;;

51  4) # Sintaxis condicionada.

52  TOOL="${3,,}"

53  LEVEL="${4,,}"

54  ;;

55 esac

56 

57 case "$TOOL" in

58  ntfsclone)

59  PARAM1="ntfsclone --force --save-image -O - $DEV"

60  ;;

61  partimage|default)

62  PARAM1="partimage -M -f3 -o -d -B gui=no -c -z0 --volume=0 save $DEV stdout"

63  ;;

64  partclone)

65  FS="$(ogGetFsType $(ogDevToDisk $DEV 2>/dev/null) 2>/dev/null)"

66  case "$FS" in

67  EXT[234]) PARAM1="partclone.extfs" ;;

68  BTRFS) PARAM1="partclone.btrfs" ;;

69  REISERFS) PARAM1="partclone.reiserfs" ;;

70  REISER4) PARAM1="partclone.reiser4" ;;

71  JFS) PARAM1="partclone.jfs" ;;

72  XFS) PARAM1="partclone.xfs" ;;

73  F2FS) PARAM1="partclone.f2fs" ;;

74  NILFS2) PARAM1="partclone.nilfs2" ;;

75  NTFS) PARAM1="partclone.ntfs" ;;

76  EXFAT) PARAM1="partclone.exfat" ;;

77  FAT16|FAT32) PARAM1="partclone.fat" ;;

78  HFS|HFSPLUS) PARAM1="partclone.hfsp" ;;

79  UFS) PARAM1="partclone.ufs" ;;

80  VMFS) PARAM1="partclone.vmfs" ;;

81  *) PARAM1="partclone.imager" ;;

82  esac

83  # Por compatibilidad, si no existe el ejecutable usar por defecto "parclone.dd".

84  which $PARAM1 &>/dev/null || PARAM1="partclone.dd"

85  PARAM1="$PARAM1 -d0 -F -c -s $DEV"

86  # Algunas versiones de partclone.dd no tienen opción "-c".

87  [ -z "$(eval ${PARAM1%% *} --help 2>&1 | grep -- -c)" ] && PARAM1="${PARAM1/ -c / }"

88  ;;

89 esac

90 # Comprobar que existe mbuffer.

91 which mbuffer &>/dev/null && PARAM2="| mbuffer -q -m 40M " || PARAM2=" "

92 

93 # Nivel de compresion.

94 case "$LEVEL" in

95  0|none) PARAM3=" > " ;;

96  1|lzop) PARAM3=" | lzop > " ;;

97  2|gzip) PARAM3=" | gzip -c > " ;;

98  3|bzip) PARAM3=" | bzip -c > " ;;

99 esac

100 

101 # Sintaxis final.

102 [ -n "$PARAM1" ] && echo "$PARAM1 $PARAM2 $PARAM3 $IMGFILE"

103 }

104 

105 

106 # ##

122 function ogRestoreImageSyntax ()

123 {

124 local TOOL COMPRESSOR LEVEL PART IMGFILE FILEHEAD INFOIMG

125 

126 

127 # Si se solicita, mostrar ayuda.

128 if [ "$*" == "help" ]; then

129  ogHelp "$FUNCNAME" "$FUNCNAME filename partition [tool] [levelcompresor]" \

130  "$FUNCNAME /opt/opengnsys/images/prueba.img /dev/sda1 [partclone] [lzop]"

131  return

132 fi

133 

134 # Error si no se reciben entre 2 y 4 parámetros.

135 [ $# -ge 2 -a $# -le 4 ] || ogRaiseError $OG_ERR_FORMAT "$*" || return $?

136 

137 # controlamos que el parametro 1 (imagen) es tipo file.

138 [ -f $1 ] || ogRaiseError $OG_ERR_NOTFOUND "$1" || return $?

139 

140 # Si 2 parametros (file-origen-, device-destino-) = ogGetImageFull($1)

141 if [ "$#" -eq 2 ]; then

142  IMGFILE=$1

143  PART=$2

144  INFOIMG=$(ogGetImageInfo $IMGFILE) || ogRaiseError $OG_ERR_NOTFOUND "No Image $1" || return $?

145  TOOL=`echo $INFOIMG | cut -f1 -d:`

146  COMPRESSOR=`echo $INFOIMG | cut -f2 -d:`

147  ogRestoreImageSyntax $IMGFILE $PART $TOOL $COMPRESSOR

148 fi

149 

150 

151 # Si cuatro parametros genera sintaxis

152 if [ "$#" -eq 4 ]; then

153  IMGFILE=$1

154  PART=$2

155  # comprobamos parametro herramienta compresion.

156  TOOL=$(echo $3 | tr [A-Z] [a-z])

157  #ogCheckProgram $TOOL

158  #comprobar parámetro compresor.

159  LEVEL=$(echo $4 | tr [A-Z] [a-z])

160  #ogCheckProgram $LEVEL

161 

162  case "$LEVEL" in

163  "0"|"none")

164  COMPRESSOR=" "

165  ;;

166  "1"|"lzop" | "LZOP")

167  COMPRESSOR=" lzop -dc "

168  ;;

169  "2"|"gzip" | "GZIP")

170  COMPRESSOR=" gzip -dc "

171  ;;

172  "3"|"bzip" | "BZIP" )

173  COMPRESSOR=" bzip -dc "

174  ;;

175  *)

176  ogRaiseError $OG_ERR_NOTFOUND "Compressor no valid $TOOL" || return $?

177  ;;

178  esac

179  #comprobar mbuffer

180  which mbuffer > /dev/null && MBUFFER="| mbuffer -q -m 40M " || MBUFFER=" "

181 

182  case "${TOOL,,}" in

183  ntfsclone)

184  TOOL="| ntfsclone --restore-image --overwrite $PART -"

185  ;;

186  partimage)

187  TOOL="| partimage -f3 -B gui=no restore $PART stdin"

188  ;;

189  partclone*)

190  # -C para que no compruebe tamaños

191  TOOL="| partclone.restore -d0 -C -I -o $PART"

192  ;;

193  dd)

194  TOOL="| pv | dd conv=sync,noerror bs=1M of=$PART"

195  ;;

196  *)

197  ogRaiseError $OG_ERR_NOTFOUND "Tools imaging no valid $TOOL" || return $?

198  ;;

199  esac

200 

201  echo "$COMPRESSOR $IMGFILE $MBUFFER $TOOL"

202 fi

203 

204 }

205 

206 

207 

208 

209 # ##

230 function ogCreateDiskImage ()

231 {

232 # Variables locales

233 local DISK PROGRAM IMGDIR IMGFILE IMGTYPE ERRCODE

234 

235 # Si se solicita, mostrar ayuda.

236 if [ "$*" == "help" ]; then

237  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk str_repo path_image" \

238  "$FUNCNAME 1 REPO /disk1"

239  return

240 fi

241 # Error si no se reciben entre 3 y 5 parámetros.

242 [ $# -ge 3 -a $# -le 5 ] || ogRaiseError $OG_ERR_FORMAT "$*" || return $?

243 

244 # Comprobar que no está bloqueada ni la partición, ni la imagen.

245 DISK="$(ogDiskToDev $1)" || return $?

246 if ogIsDiskLocked $1; then

247  ogRaiseError $OG_ERR_LOCKED "$MSG_LOCKED $1"

248  return $?

249 fi

250 IMGTYPE="dsk" # Extensión genérica de imágenes de disco.

251 IMGDIR=$(ogGetParentPath "$2" "$3")

252 [ -n "$IMGDIR" ] || ogRaiseError $OG_ERR_NOTFOUND "$2 $(dirname $3)" || return $?

253 IMGFILE="$IMGDIR/$(basename "$3").$IMGTYPE"

254 if ogIsImageLocked "$IMGFILE"; then

255  ogRaiseError $OG_ERR_LOCKED "$MSG_IMAGE $3, $4"

256  return $?

257 fi

258 

259 # No guardar imagen en el propio disco (disco no incluido en el camino del repositorio).

260 if [[ $(ogGetPath "$2" /) =~ ^$DISK ]]; then

261  ogRaiseError $OG_ERR_IMAGE "$2 = $DISK"

262  return $?

263 fi

264 

265 # Generar la instruccion a ejecutar antes de aplicar los bloqueos.

266 PROGRAM=$(ogCreateImageSyntax $DISK $IMGFILE)

267 # Desmontar todos los sistemas de archivos del disco, bloquear disco e imagen.

268 ogUnmountAll $1 2>/dev/null

269 ogLockDisk $1 || return $?

270 ogLockImage "$2" "$3.$IMGTYPE" || return $?

271 

272 # Crear Imagen.

273 trap "ogUnlockDisk $1; ogUnlockImage "$3" "$4.$IMGTYPE"; rm -f $IMGFILE" 1 2 3 6 9

274 eval $PROGRAM

275 

276 # Controlar salida de error, crear fichero de información y desbloquear partición.

277 ERRCODE=$?

278 if [ $ERRCODE == 0 ]; then

279  echo "$(ogGetImageInfo $IMGFILE):$(ogGetHostname)" > $IMGFILE.info

280 else

281  ogRaiseError $OG_ERR_IMAGE "$1 $2 $IMGFILE"

282  rm -f "$IMGFILE"

283 fi

284 # Desbloquear disco e imagen.

285 ogUnlockDisk $1

286 ogUnlockImage "$2" "$3.$IMGTYPE"

287 return $ERRCODE

288 }

289 

290 

291 # ##

320 function ogCreateImage ()

321 {

322 # Variables locales

323 local PART PROGRAM IMGDIR IMGFILE IMGTYPE ERRCODE

324 

325 # Si se solicita, mostrar ayuda.

326 if [ "$*" == "help" ]; then

327  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_npart str_repo path_image" \

328  "$FUNCNAME 1 1 REPO /aula1/win7"

329  return

330 fi

331 # Error si no se reciben entre 4 y 6 parámetros.

332 [ $# -ge 4 -a $# -le 6 ] || ogRaiseError $OG_ERR_FORMAT "$*" || return $?

333 

334 # Comprobar que no está bloqueada ni la partición, ni la imagen.

335 PART="$(ogDiskToDev $1 $2)" || return $?

336 if ogIsLocked $1 $2; then

337  ogRaiseError $OG_ERR_LOCKED "$MSG_LOCKED $1, $2"

338  return $?

339 fi

340 

341 IMGTYPE="img" # Extensión genérica de imágenes.

342 IMGDIR=$(ogGetParentPath "$3" "$4")

343 [ -n "$IMGDIR" ] || ogRaiseError $OG_ERR_NOTFOUND "$3 $(dirname $4)" || return $?

344 

345 IMGFILE="$IMGDIR/$(basename "$4").$IMGTYPE"

346 if ogIsImageLocked "$IMGFILE"; then

347  ogRaiseError $OG_ERR_LOCKED "$MSG_IMAGE $3, $4"

348  return $?

349 fi

350 # Generar la instruccion a ejecutar antes de aplicar los bloqueos.

351 PROGRAM=$(ogCreateImageSyntax $PART $IMGFILE $5 $6)

352 # Desmontar partición, bloquear partición e imagen.

353 ogUnmount $1 $2 2>/dev/null

354 ogLock $1 $2 || return $?

355 ogLockImage "$3" "$4.$IMGTYPE" || return $?

356 

357 # Crear Imagen.

358 trap "ogUnlock $1 $2; ogUnlockImage "$3" "$4.$IMGTYPE"; rm -f $IMGFILE" 1 2 3 6 9

359 eval $PROGRAM

360 

361 # Controlar salida de error, crear fichero de información y desbloquear partición.

362 ERRCODE=$?

363 if [ $ERRCODE == 0 ]; then

364  echo "$(ogGetImageInfo $IMGFILE):$(ogGetHostname)" > $IMGFILE.info

365  cp -f $IMGFILE.info /tmp/image.info

366 else

367  ogRaiseError $OG_ERR_IMAGE "$1 $2 $IMGFILE"

368  rm -f "$IMGFILE"

369 fi

370 # Desbloquear partición e imagen.

371 ogUnlock $1 $2

372 ogUnlockImage "$3" "$4.$IMGTYPE"

373 return $ERRCODE

374 }

375 

376 

377 # ##

395 function ogCreateMbrImage ()

396 {

397 # Variables locales

398 local DISK IMGDIR IMGFILE

399 # Si se solicita, mostrar ayuda.

400 if [ "$*" == "help" ]; then

401  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk str_repo path_image" \

402  "$FUNCNAME 1 REPO /aula1/mbr"

403  return

404 fi

405 # Error si no se reciben 3 parámetros.

406 [ $# == 3 ] || ogRaiseError $OG_ERR_FORMAT || return $?

407 

408 DISK=$(ogDiskToDev "$1") || return $?

409 IMGDIR=$(ogGetParentPath "$2" "$3")

410 [ -n "$IMGDIR" ] || ogRaiseError $OG_ERR_NOTFOUND "$2 $(dirname $3)" || return $?

411 IMGFILE="$IMGDIR/$(basename "$3").mbr"

412 

413 # Crear imagen del MBR.

414 dd if="$DISK" of="$IMGFILE" bs=512 count=1 || ogRaiseError $OG_ERR_IMAGE "$1 $IMGFILE" || return $?

415 }

416 

417 

418 # ##

433 function ogCreateBootLoaderImage ()

434 {

435 # Variables locales

436 local DISK IMGDIR IMGFILE

437 # Si se solicita, mostrar ayuda.

438 if [ "$*" == "help" ]; then

439  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk str_repo path_image" \

440  "$FUNCNAME 1 REPO /aula1/mbr"

441  return

442 fi

443 # Error si no se reciben 3 parámetros.

444 [ $# == 3 ] || ogRaiseError $OG_ERR_FORMAT || return $?

445 

446 DISK=$(ogDiskToDev "$1") || return $?

447 IMGDIR=$(ogGetParentPath "$2" "$3")

448 [ -n "$IMGDIR" ] || ogRaiseError $OG_ERR_NOTFOUND "$2 $(dirname $3)" || return $?

449 IMGFILE="$IMGDIR/$(basename "$3").mbr"

450 

451 # Crear imagen del Boot Loader dentro del MBR.

452 dd if="$DISK" of="$IMGFILE" bs=446 count=1 || ogRaiseError $OG_ERR_IMAGE "$1 $IMGFILE" || return $?

453 }

454 

455 # ##

476 function ogGetSizeParameters ()

477 {

478 local REPO MNTDIR SIZEDATA KERNELVERSION SIZEREQUIRED FACTORGZIP FACTORLZOP FACTORSYNC SIZEFREE

479 local IMGTYPE IMGDIR IMGFILE IMGEXT IMGSIZE

480 

481 # Si se solicita, mostrar ayuda.

482 if [ "$*" == "help" ]; then

483  ogHelp "$FUNCNAME" "$FUNCNAME num_disk num_part str_repo path_imgname [monolit|sync|diff]" \

484  "if $FUNCNAME 1 2 REPO Windows10 sync ; then ...; fi" \

485  "if $FUNCNAME 1 6 Ubuntu16 CACHE ; then ...; fi"

486  return

487 fi

488 # Error si no se reciben 1 o 2 parámetros.

489 [ $# -lt 4 ] && return $(ogRaiseError session $OG_ERR_FORMAT "$MSG_FORMAT: $PROG ndisco nparticion REPO|CACHE imgname [monolit|sync|diff]" ; echo $?)

490 

491 # Recogemos parametros

492 REPO=${3^^}

493 IMGTYPE="_${5^^}_"

494 

495 MNTDIR=$(ogMount $1 $2)

496 if [ "$MNTDIR" == "" ]; then

497  ogRaiseError $OG_ERR_PARTITION "$1 $2"

498  return $?

499 fi

500 

501 # Datos contenidos en la particion o en la lista de archivos de contiene la diferencial.

502 if [ "$IMGTYPE" == "_DIFF_" ]; then

503  [ -r /tmp/ogimg.info ] || return $(ogRaiseError session $OG_ERR_NOTFOUND "/tmp/ogimg.info"; echo $?)

504  cd $MNTDIR

505  SIZEDATA=$(grep -v "\/$" /tmp/ogimg.info | tr '\n' '\0'| du -x -c --files0-from=- 2>/dev/null|tail -n1 |cut -f1)

506  cd /

507 else

508  SIZEDATA=$(df -k | grep $MNTDIR\$ | awk '{print $3}')

509 fi

510 

511 #Aplicar factor de compresion

512 if [ "$IMGTYPE" == "_SYNC_" -o "$IMGTYPE" == "_DIFF_" ]; then

513 

514  # Sistema de fichero de la imagen según kernel, menor que 3.7 EXT4. comparamos revision

515  KERNELVERSION=$(uname -r| awk '{printf("%d",$1);sub(/[0-9]*\./,"",$1);printf(".%02d",$1)}')

516  [ $KERNELVERSION \< 3.07 ] && IMGFS="EXT4" || IMGFS=${IMGFS:-"BTRFS"}

517  FACTORSYNC=${FACTORSYNC:-"130"}

518  # Si IMGFS="BTRFS" la compresion es mayor.

519  [ $IMGFS == "BTRFS" ] && let FACTORSYNC=$FACTORSYNC-20

520 

521  let SIZEREQUIRED=$SIZEDATA*$FACTORSYNC/100

522  # El tamaño mínimo del sistema de ficheros btrfs es 250M, ponemos 300

523  [ $SIZEREQUIRED -lt 300000 ] && SIZEREQUIRED=300000

524 

525 else

526  FACTORGZIP=55/100

527  FACTORLZOP=65/100

528  let SIZEREQUIRED=$SIZEDATA*$FACTORLZOP

529 fi

530 

531 #Comprobar espacio libre en el contenedor.

532 [ "$REPO" == "CACHE" ] && SIZEFREE=$(ogGetFreeSize `ogFindCache`)

533 [ "$REPO" == "REPO" ] && SIZEFREE=$(df -k | grep $OGIMG | awk '{print $4}')

534 

535 # Comprobamos si existe una imagen con el mismo nombre en $REPO

536 # En sincronizadas restamos tamaño de la imagen y en monoloticas de la .ant

537 case "${IMGTYPE}" in

538  _DIFF_) IMGEXT="img.diff"

539  ;;

540  _SYNC_) IMGEXT="img"

541  ;;

542  *) IMGEXT="img.ant"

543  ;;

544 esac

545 

546 IMGDIR=$(ogGetParentPath "$REPO" "/$4")

547 IMGFILE=$(ogGetPath "$IMGDIR/$(basename "/$4").$IMGEXT")

548 if [ -z "$IMGFILE" ]; then

549  IMGSIZE=0

550 else

551  IMGSIZE=$(ls -s "$IMGFILE" | cut -f1 -d" ")

552 fi

553 

554 let SIZEFREE=$SIZEFREE+$IMGSIZE

555 

556 [ "$SIZEREQUIRED" -lt "$SIZEFREE" ] && ISENOUGHSPACE=TRUE || ISENOUGHSPACE=FALSE

557 

558 echo $SIZEDATA $SIZEREQUIRED $SIZEFREE $ISENOUGHSPACE

559 

560 }

561 

562 # ##

577 function ogIsImageLocked ()

578 {

579 # Si se solicita, mostrar ayuda.

580 if [ "$*" == "help" ]; then

581  ogHelp "$FUNCNAME" "$FUNCNAME [str_repo] path_image" \

582  "if $FUNCNAME /opt/opengnsys/images/aula1/win7.img; then ...; fi" \

583  "if $FUNCNAME REPO /aula1/win7.img; then ...; fi"

584  return

585 fi

586 # Error si no se reciben 1 o 2 parámetros.

587 [ $# -lt 1 -o $# -gt 2 ] && return 1

588 

589 # Comprobar si existe el fichero de bloqueo.

590 test -n "$(ogGetPath $@.lock)"

591 }

592 

593 

594 # ##

607 function ogLockImage ()

608 {

609 # Variables locales

610 local IMGDIR

611 

612 # Si se solicita, mostrar ayuda.

613 if [ "$*" == "help" ]; then

614  ogHelp "$FUNCNAME" "$FUNCNAME [str_repo] path_image" \

615  "$FUNCNAME /opt/opengnsys/images/aula1/win7.img" \

616  "$FUNCNAME REPO /aula1/win7.img"

617  return

618 fi

619 # Error si no se reciben 1 o 2 parámetros.

620 [ $# == 1 -o $# == 2 ] || ogRaiseError $OG_ERR_FORMAT || return $?

621 # Comprobar que existe directorio de imagen

622 IMGDIR=$(ogGetParentPath $@) || return $?

623 # Crear fichero de bloqueo.

624 touch $IMGDIR/$(basename "${!#}").lock 2>/dev/null || ogRaiseError $OG_ERR_NOTWRITE "$*" || return $?

625 }

626 

627 

628 # ##

647 function ogRestoreDiskImage ()

648 {

649 # Variables locales

650 local DISK DISKSIZE IMGFILE IMGTYPE IMGSIZE PROGRAM ERRCODE

651 

652 # Si se solicita, mostrar ayuda.

653 if [ "$*" == "help" ]; then

654  ogHelp "$FUNCNAME" "$FUNCNAME str_repo path_image int_ndisk" \

655  "$FUNCNAME REPO /aula1/win7 1"

656  return

657 fi

658 # Error si no se reciben 4 parámetros.

659 [ $# == 3 ] || ogRaiseError $OG_ERR_FORMAT || return $?

660 # Procesar parámetros.

661 DISK="$(ogDiskToDev $3)" || return $(ogRaiseError $OG_ERR_NOTFOUND " $3 $4"; echo $?)

662 IMGTYPE="dsk"

663 IMGFILE=$(ogGetPath "$1" "$2.$IMGTYPE")

664 [ -r "$IMGFILE" ] || return $(ogRaiseError $OG_ERR_NOTFOUND " $3 $4"; echo $?)

665 

666 # comprobamos consistencia de la imagen

667 ogGetImageInfo $IMGFILE >/dev/null || return $(ogRaiseError $OG_ERR_IMAGE " $1 $2"; echo $?)

668 

669 #/* (Comienzo comentario Doxygen)

670 # Error si la imagen no cabe en la particion.

671 #IMGSIZE=$(ogGetImageSize "$1" "$2") || return $(ogRaiseError $OG_ERR_IMAGE " $1 $2"; echo $?)

672 #DISKSIZE=$(ogGetDiskSize $3)

673 #if [ $IMGSIZE -gt $DISKSIZE ]; then

674 # ogRaiseError $OG_ERR_IMGSIZEPARTITION "$DISKSIZE < $IMGSIZE"

675 # return $?

676 #fi

677 #*/ (Fin comentario Doxygen)

678 

679 # Comprobar el bloqueo de la imagen y de la partición.

680 if ogIsImageLocked "$IMGFILE"; then

681  ogRaiseError $OG_ERR_LOCKED "$MSG_IMAGE $1, $2.$IMGTYPE"

682  return $?

683 fi

684 if ogIsDiskLocked $3; then

685  ogRaiseError $OG_ERR_LOCKED "$MSG_DISK $3"

686  return $?

687 fi

688 # Solicitamos la generación de la instruccion a ejecutar

689 PROGRAM=$(ogRestoreImageSyntax $IMGFILE $DISK)

690 

691 # Bloquear el disco

692 ogLockDisk $3 || return $?

693 trap "ogUnlockDisk $3" 1 2 3 6 9

694 

695 # Ejecutar restauración según el tipo de imagen.

696 eval $PROGRAM

697 

698 ERRCODE=$?

699 if [ $ERRCODE != 0 ]; then

700  ogRaiseError $OG_ERR_IMAGE "$IMGFILE, $3, $4"

701 fi

702 ogUnlockDisk $3 $4

703 return $ERRCODE

704 }

705 

706 

707 # ##

737 function ogRestoreImage ()

738 {

739 # Variables locales

740 local PART PARTSIZE IMGFILE IMGTYPE IMGSIZE FSTYPE PROGRAM ERRCODE

741 

742 # Si se solicita, mostrar ayuda.

743 if [ "$*" == "help" ]; then

744  ogHelp "$FUNCNAME" "$FUNCNAME str_repo path_image int_ndisk int_npart" \

745  "$FUNCNAME REPO /aula1/win7 1 1"

746  return

747 fi

748 # Error si no se reciben 4 parámetros.

749 [ $# == 4 ] || ogRaiseError $OG_ERR_FORMAT || return $?

750 # Procesar parámetros.

751 PART="$(ogDiskToDev $3 $4)" || return $(ogRaiseError $OG_ERR_NOTFOUND " $3 $4"; echo $?)

752 #IMGTYPE=$(ogGetImageType "$1" "$2")

753 IMGTYPE=img

754 IMGFILE=$(ogGetPath "$1" "$2.$IMGTYPE")

755 [ -r "$IMGFILE" ] || return $(ogRaiseError $OG_ERR_NOTFOUND " $3 $4"; echo $?)

756 # comprobamos consistencia de la imagen

757 ogGetImageInfo $IMGFILE >/dev/null || return $(ogRaiseError $OG_ERR_IMAGE " $1 $2"; echo $?)

758 

759 # Error si la imagen no cabe en la particion.

760 IMGSIZE=$(ogGetImageSize "$1" "$2") || return $(ogRaiseError $OG_ERR_IMAGE " $1 $2"; echo $?)

761 #TODO:

762 #Si la particion no esta formateado o tiene problemas formateamos

763 ogMount $3 $4 || ogFormat $3 $4

764 PARTSIZE=$(ogGetPartitionSize $3 $4)

765 if [ $IMGSIZE -gt $PARTSIZE ]; then

766  ogRaiseError $OG_ERR_IMGSIZEPARTITION " $PARTSIZE < $IMGSIZE"

767  return $?

768 fi

769 # Comprobar el bloqueo de la imagen y de la partición.

770 if ogIsImageLocked "$IMGFILE"; then

771  ogRaiseError $OG_ERR_LOCKED "$MSG_IMAGE $1, $2.$IMGTYPE"

772  return $?

773 fi

774 if ogIsLocked $3 $4; then

775  ogRaiseError $OG_ERR_LOCKED "$MSG_PARTITION $3, $4"

776  return $?

777 fi

778 

779 # Solicitamos la generación de la instruccion a ejecutar

780 # Atención: no se comprueba el tipo de sistema de archivos.

781 # Atención: no se comprueba incongruencia entre partición e imagen.

782 PROGRAM=`ogRestoreImageSyntax $IMGFILE $PART`

783 

784 # Desmontar y bloquear partición.

785 ogUnmount $3 $4 2>/dev/null || return $(ogRaiseError $OG_ERR_PARTITION " $3 $4"; echo $?)

786 ogLock $3 $4 || return $?

787 trap "ogUnlock $3 $4" 1 2 3 6 9

788 

789 # Ejecutar restauración según el tipo de imagen.

790 eval $PROGRAM

791 

792 ERRCODE=$?

793 if [ $ERRCODE != 0 ]; then

794  ogRaiseError $OG_ERR_IMAGE "$IMGFILE, $3, $4"

795 fi

796 ogUnlock $3 $4

797 return $ERRCODE

798 }

799 

800 

801 # ##

818 function ogRestoreMbrImage ()

819 {

820 # Variables locales

821 local DISK IMGFILE

822 # Si se solicita, mostrar ayuda.

823 if [ "$*" == "help" ]; then

824  ogHelp "$FUNCNAME" "$FUNCNAME str_repo path_image int_ndisk" \

825  "$FUNCNAME REPO /aula1/mbr 1"

826  return

827 fi

828 # Error si no se reciben 3 parámetros.

829 [ $# == 3 ] || ogRaiseError $OG_ERR_FORMAT || return $?

830 # Procesar parámetros.

831 DISK=$(ogDiskToDev "$3") || return $?

832 IMGFILE=$(ogGetPath "$1" "$2.mbr")

833 [ -r "$IMGFILE" ] || ogRaiseError $OG_ERR_NOTFOUND "$IMGFILE" || return $?

834 

835 # Restaurar imagen del MBR.

836 dd if="$IMGFILE" of="$DISK" bs=512 count=1 || ogRaiseError $OG_ERR_IMAGE "$1 $IMGFILE" || return $?

837 }

838 

839 

840 # ##

854 function ogRestoreBootLoaderImage ()

855 {

856 # Variables locales

857 local DISK IMGFILE

858 # Si se solicita, mostrar ayuda.

859 if [ "$*" == "help" ]; then

860  ogHelp "$FUNCNAME" "$FUNCNAME str_repo path_image int_ndisk" \

861  "$FUNCNAME REPO /aula1/mbr 1"

862  return

863 fi

864 # Error si no se reciben 3 parámetros.

865 [ $# == 3 ] || ogRaiseError $OG_ERR_FORMAT || return $?

866 # Procesar parámetros.

867 DISK=$(ogDiskToDev "$3") || return $?

868 IMGFILE=$(ogGetPath "$1" "$2.mbr")

869 [ -r "$IMGFILE" ] || ogRaiseError $OG_ERR_NOTFOUND "$IMGFILE" || return $?

870 

871 # Restaurar imagen del MBR.

872 dd if="$IMGFILE" of="$DISK" bs=446 count=1 || ogRaiseError $OG_ERR_IMAGE "$1 $IMGFILE" || return $?

873 }

874 

875 # ##

888 function ogUnlockImage ()

889 {

890 # Si se solicita, mostrar ayuda.

891 if [ "$*" == "help" ]; then

892  ogHelp "$FUNCNAME" "$FUNCNAME [str_repo] path_image" \

893  "$FUNCNAME /opt/opengnsys/images/aula1/win7.img" \

894  "$FUNCNAME REPO /aula1/win7.img"

895  return

896 fi

897 # Error si no se reciben 1 o 2 parámetros.

898 [ $# == 1 -o $# == 2 ] || ogRaiseError $OG_ERR_FORMAT || return $?

899 

900 # Borrar fichero de bloqueo para la imagen.

901 rm -f $(ogGetPath $@.lock)

902 }

903 

904 

905 # ##

921 

922 function ogGetImageInfo ()

923 {

924 # Si se solicita, mostrar ayuda.

925 if [ "$*" == "help" ]; then

926  ogHelp "$FUNCNAME" "$FUNCNAME path_filename" \

927  "$FUNCNAME /opt/opengnsys/images/prueba.img ==> PARTCLONE:LZOP:NTFS:5642158"

928  return

929 fi

930 

931 # Error si no se recibe 1 parámetro.

932 [ $# == 1 ] || ogRaiseError $OG_ERR_FORMAT || return $?

933 

934 #comprobando que el parametro uno es un file.

935 [ -f $1 ] || ogRaiseError $OG_ERR_NOTFOUND "$1" || return $?

936 

937 local TOOLS COMPRESSOR IMGFILE FILEHEAD FS FSPLUS SIZE SIZEFACTOR PARTIMAGEINFO PARTCLONEINFO NTFSCLONEINFO IMGDETECT

938 IMGDETECT="FALSE"

939 

940 IMGFILE=$1

941 FILEHEAD=/tmp/`basename $IMGFILE`.infohead

942 COMPRESSOR=`file $IMGFILE | awk '{print $2}'`

943 ogCheckStringInGroup "$COMPRESSOR" "gzip lzop" || ogRaiseError $OG_ERR_IMAGE "Image format is not valid $IMGFILE" || return $?

944 $($COMPRESSOR -dc $IMGFILE 2>/dev/null | head -n 40 > $FILEHEAD) || ogRaiseError $OG_ERR_IMAGE "Image format is not valid $IMGFILE" || return $?

945 

946 ## buscando Primera opción.

947 if [ "$IMGDETECT" == "FALSE" ]

948 then

949  PARTCLONEINFO=$(LC_ALL=C partclone.info $FILEHEAD 2>&1)

950  if `echo $PARTCLONEINFO | grep size > /dev/null`

951  then

952  TOOLS=PARTCLONE

953  FS=$(echo $PARTCLONEINFO | awk '{gsub(/: /,"\n"); print toupper($8);}')

954  if [[ "$FS" == "HFS" || "$FS" == "HFSPLUS" || "$FS" == "FAT32" ]]; then

955  FSPLUS=$(echo $PARTCLONEINFO | awk '{gsub(/: /,"\n"); print toupper($9);}')

956  echo $PARTCLONEINFO | grep GB > /dev/null && SIZEFACTOR=1000000 || SIZEFACTOR=1024

957  if [ "$FSPLUS" == "PLUS" ]; then

958  FS=$FS$FSPLUS

959  SIZE=$(echo $PARTCLONEINFO | awk -v FACTOR=$SIZEFACTOR '{printf "%d\n", $17*FACTOR;}')

960  else

961  SIZE=$(echo $PARTCLONEINFO | awk -v FACTOR=$SIZEFACTOR '{printf "%d\n", $16*FACTOR;}')

962  fi

963  else

964  echo $PARTCLONEINFO | grep GB > /dev/null && SIZEFACTOR=1000000 || SIZEFACTOR=1024

965  SIZE=$(echo $PARTCLONEINFO | awk -v FACTOR=$SIZEFACTOR '{gsub(/: /,"\n"); printf "%d\n", $11*FACTOR;}')

966  fi

967  IMGDETECT="TRUE"

968  fi

969 fi

970 #buscando segunda opcion.

971 if [ "$IMGDETECT" == "FALSE" -a ! -f /dev/loop2 ]

972 then

973  cat $FILEHEAD | grep -w ntfsclone-image > /dev/null && NTFSCLONEINFO=$(cat $FILEHEAD | ntfsclone --restore --overwrite /dev/loop2 - 2>&1)

974  if `echo $NTFSCLONEINFO | grep ntfsclone > /dev/null`

975  then

976  TOOLS=NTFSCLONE

977  SIZE=$(echo $NTFSCLONEINFO | awk '{gsub(/\(|\)|\./,""); printf "%d\n",$17/1000;}')

978  FS=NTFS

979  IMGDETECT="TRUE"

980  fi

981 fi

982 ## buscando Tercer opción.

983 if [ "$IMGDETECT" == "FALSE" ]

984 then

985  PARTIMAGEINFO=$(partimage -B gui=no imginfo "$FILEHEAD" 2>&1)

986  if `echo $PARTIMAGEINFO | grep Partition > /dev/null`

987  then

988  TOOLS=PARTIMAGE

989  FS=$(echo $PARTIMAGEINFO | awk '{gsub(/ /,"\n"); print $17;}' | awk '{sub(/\.\.+/," "); print toupper($2)}')

990  SIZE=$( echo $PARTIMAGEINFO | awk '{gsub(/ /,"\n"); print $36;}' | awk '{sub(/\.\.+/," "); printf "%d\n",$2*1024*1024;}')

991  IMGDETECT="TRUE"

992  fi

993  if file $FILEHEAD 2> /dev/null | grep -q "boot sector"; then

994  TOOLS="partclone.dd"

995  FS=

996  SIZE=

997  IMGDETECT="TRUE"

998  fi

999 fi

1000 #comprobamos valores #Chequeamos los valores devueltos.

1001 if [ -z "$TOOLS" -o -z "$COMPRESSOR" -o "$IMGDETECT" == "FALSE" ]

1002 then

1003  ogRaiseError $OG_ERR_IMAGE "Image format is not valid $IMGFILE" || return $?

1004 else

1005  COMPRESSOR=$(echo $COMPRESSOR | tr [a-z] [A-Z])

1006  echo $TOOLS:$COMPRESSOR:$FS:$SIZE

1007 fi

1008 }

1009 

1010 # ##

1024 

1025 function ogGetImageProgram ()

1026 {

1027 local IMGFILE

1028 # Si se solicita, mostrar ayuda.

1029 if [ "$*" == "help" ]; then

1030  ogHelp "$FUNCNAME" "$FUNCNAME str_repo path_image" \

1031  "$FUNCNAME REPO prueba ==> PARTCLONE"

1032  return

1033 fi

1034 # Error si no se reciben 2 parámetros.

1035 [ $# == 2 ] || ogRaiseError $OG_ERR_FORMAT || return $?

1036 IMGFILE=$(ogGetPath "$1" "$2.img")

1037 [ -r "$IMGFILE" ] || ogRaiseError $OG_ERR_NOTFOUND "$IMGFILE" || return $?

1038 ogGetImageInfo $IMGFILE | awk -F: '{print $1}'

1039 }

1040 

1041 # ##

1055 function ogGetImageCompressor ()

1056 {

1057 local IMGFILE

1058 # Si se solicita, mostrar ayuda.

1059 if [ "$*" == "help" ]; then

1060  ogHelp "$FUNCNAME" "$FUNCNAME str_repo path_image" \

1061  "$FUNCNAME REPO prueba ==> LZOP"

1062  return

1063 fi

1064 # Error si no se reciben 2 parámetros.

1065 [ $# == 2 ] || ogRaiseError $OG_ERR_FORMAT || return $?

1066 IMGFILE=$(ogGetPath "$1" "$2.img")

1067 [ -r "$IMGFILE" ] || ogRaiseError $OG_ERR_NOTFOUND "$IMGFILE" || return $?

1068 ogGetImageInfo $IMGFILE | awk -F: '{print $2}'

1069 }

1070 

1071 

1072 # ##

1086 function ogGetImageType ()

1087 {

1088 local IMGFILE

1089 # Si se solicita, mostrar ayuda.

1090 if [ "$*" == "help" ]; then

1091  ogHelp "$FUNCNAME" "$FUNCNAME str_repo path_image" \

1092  "$FUNCNAME REPO prueba ==> NTFS"

1093  return

1094 fi

1095 # Error si no se reciben 2 parámetros.

1096 [ $# == 2 ] || ogRaiseError $OG_ERR_FORMAT || return $?

1097 IMGFILE=$(ogGetPath "$1" "$2.img")

1098 [ -r "$IMGFILE" ] || ogRaiseError $OG_ERR_NOTFOUND "$IMGFILE" || return $?

1099 ogGetImageInfo $IMGFILE | awk -F: '{print $3}'

1100 }

1101 

1102 

1103 # ##

1117 function ogGetImageSize ()

1118 {

1119 # Variables locales

1120 local IMGFILE

1121 

1122 # Si se solicita, mostrar ayuda.

1123 if [ "$*" == "help" ]; then

1124  ogHelp "$FUNCNAME" "$FUNCNAME str repo path_image" \

1125  "$FUNCNAME REPO prueba ==> 5642158"

1126  return

1127 fi

1128 # Error si no se reciben 2 parámetros.

1129 [ $# == 2 ] || ogRaiseError $OG_ERR_FORMAT || return $?

1130 # Error si el fichero de imagen no es accesible.

1131 IMGFILE=$(ogGetPath "$1" "$2.img")

1132 [ -r "$IMGFILE" ] || ogRaiseError $OG_ERR_NOTFOUND "$IMGFILE" || return $?

1133 

1134 # Devuelve el tamaño de la imagen en KB.

1135 ogGetImageInfo $IMGFILE | awk -F: '{print $4}'

1136 }

1137 

1138 

1139 # ##

1154 function ogCreateGptImage ()

1155 {

1156 # Variables locales

1157 local DISK IMGDIR IMGFILE

1158 # Si se solicita, mostrar ayuda.

1159 if [ "$*" == "help" ]; then

1160  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk path_dir str_image" \

1161  "$FUNCNAME 1 REPO /aula1/gpt"

1162  return

1163 fi

1164 # Error si no se reciben 3 parámetros.

1165 [ $# == 3 ] || ogRaiseError $OG_ERR_FORMAT || return $?

1166 

1167 DISK=$(ogDiskToDev "$1") || return $?

1168 IMGDIR=$(ogGetParentPath "$2" "$3")

1169 [ -n "$IMGDIR" ] || ogRaiseError $OG_ERR_NOTFOUND "$2 $(dirname $3)" || return $?

1170 IMGFILE="$IMGDIR/$(basename "$3").gpt"

1171 

1172 # Crear imagen de la tabla GPT.

1173 sgdisk -b="$IMGFILE" "$DISK" || ogRaiseError $OG_ERR_IMAGE "$1 $IMGFILE" || return $?

1174 }

1175 

1176 # ##

1190 function ogRestoreGptImage ()

1191 {

1192 # Variables locales

1193 local DISK IMGFILE

1194 # Si se solicita, mostrar ayuda.

1195 if [ "$*" == "help" ]; then

1196  ogHelp "$FUNCNAME" "$FUNCNAME path_dir str_image int_ndisk" \

1197  "$FUNCNAME REPO /aula1/gpt 1"

1198  return

1199 fi

1200 # Error si no se reciben 3 parámetros.

1201 [ $# == 3 ] || ogRaiseError $OG_ERR_FORMAT || return $?

1202 # Procesar parámetros.

1203 DISK=$(ogDiskToDev "$3") || return $?

1204 IMGFILE=$(ogGetPath "$1" "$2.gpt")

1205 [ -r "$IMGFILE" ] || ogRaiseError $OG_ERR_NOTFOUND "$IMGFILE" || return $?

1206 

1207 # Restaurar tabla GPT del disco.

1208 sgdisk -l="$IMGFILE" "$DISK" || ogRaiseError $OG_ERR_IMAGE "$1 $IMGFILE" || return $?

1209 }

1210