1 #!/bin/bash

2 #

12 # ##

44 function ogBoot ()

45 {

46 # Variables locales.

47 local PART TYPE MNTDIR PARAMS KERNEL INITRD APPEND FILE LOADER f

48 local EFIDISK EFIPART EFIDIR BOOTLABEL BOOTLOADER BOOTNO DIRGRUB b

49 

50 # Si se solicita, mostrar ayuda.

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

52  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_nfilesys [str_kernel str_initrd str_kernelparams]" \

53  "$FUNCNAME 1 1" "$FUNCNAME 1 2 \"/boot/vmlinuz /boot/initrd.img root=/dev/sda2 ro\""

54  return

55 fi

56 # Error si no se reciben 2 o 3 parámetros.

57 [ $# == 2 ] || [ $# == 3 ] || ogRaiseError $OG_ERR_FORMAT || return $?

58 

59 # Detectar tipo de sistema de archivos y montarlo.

60 PART=$(ogDiskToDev $1 $2) || return $?

61 TYPE=$(ogGetOsType $1 $2) || return $?

62 # Error si no puede montar sistema de archivos.

63 MNTDIR=$(ogMount $1 $2) || return $?

64 

65 case "$TYPE" in

66  Linux|Android)

67  # Si no se indican, obtiene los parámetros de arranque para Linux.

68  PARAMS="${3:-$(ogLinuxBootParameters $1 $2 2>/dev/null)}"

69  # Si no existe y el UEFI buscar en particion ESP

70  [ -z "$PARAMS" ] && ogIsEfiActive && PARAMS="$(ogLinuxBootParameters $(ogGetEsp))"

71  # Si no existe, buscar sistema de archivo /boot en /etc/fstab.

72  if [ -z "$PARAMS" -a -e $MNTDIR/etc/fstab ]; then

73  # Localizar S.F. /boot en /etc/fstab del S.F. actual.

74  PART=$(ogDevToDisk $(awk '$1!="#" && $2=="/boot" {print $1}' $MNTDIR/etc/fstab))

75  # Montar S.F. de /boot.

76  MNTDIR=$(ogMount $PART) || return $?

77  # Buscar los datos de arranque.

78  PARAMS=$(ogLinuxBootParameters $PART) || exit $?

79  fi

80  read -e KERNEL INITRD APPEND <<<"$PARAMS"

81  # Si no hay kernel, no hay sistema operativo.

82  [ -n "$KERNEL" -a -e "$MNTDIR/$KERNEL" ] || ogRaiseError $OG_ERR_NOTOS "$1 $2 ($TYPE)" || return $?

83  # Arrancar de partición distinta a la original.

84  [ -e "$MNTDIR/etc" ] && APPEND=$(echo $APPEND | awk -v P="$PART " '{sub (/root=[-+=_/a-zA-Z0-9]* /,"root="P);print}')

85  # Comprobar tipo de sistema.

86  if ogIsEfiActive; then

87  # Comprobar si el Kernel está firmado.

88  if ! file -k "$MNTDIR/$KERNEL" | grep -q "EFI app"; then

89  ogRaiseError $OG_ERR_NOTOS "$1 $2 ($TYPE, EFI)"

90  return $?

91  fi

92 

93  BOOTLABEL=$(printf "Part-%02d-%02d" $1 $2)

94  BOOTLOADER="shimx64.efi"

95  # Obtener parcición EFI.

96  read -e EFIDISK EFIPART <<<"$(ogGetEsp)"

97  # TODO: Comprobamos que existe la BOOTLABEL, si no buscamos por sistema operativo

98  if [ "$(ogGetPath $EFIDISK $EFIPART EFI/$BOOTLABEL)" == "" ]; then

99  OSVERSION="$(ogGetOsVersion $1 $2)"

100  case $OSVERSION in

101  *SUSE*)

102  BOOTLABEL="opensuse"

103  ;;

104  *Fedora*)

105  BOOTLABEL="fedora"

106  ;;

107  *Ubuntu*)

108  BOOTLABEL="ubuntu"

109  ;;

110  *)

111  ogRaiseError $OG_ERR_NOTFOUND "$EFIDISK $EFIPART Boot loader"; return $?

112  ;;

113  esac

114  fi

115 

116  # Crear orden de arranque (con unos valores por defecto).

117  ogNvramAddEntry $BOOTLABEL "/EFI/$BOOTLABEL/Boot/$BOOTLOADER" TRUE

118  # Marcar próximo arranque y reiniciar.

119  ogNvramSetNext "$BOOTLABEL"

120  reboot

121  else

122  # Arranque BIOS: configurar kernel Linux con los parámetros leídos de su GRUB.

123  kexec -l "${MNTDIR}${KERNEL}" --append="$APPEND" --initrd="${MNTDIR}${INITRD}"

124  nohup bash -c 'sleep 2 && pkill ogclient' >/dev/null 2>&1 &

125  nohup bash -c 'sleep 3 && kexec -e' >/dev/null 2>&1 &

126  fi

127  ;;

128  Windows)

129  # Comprobar tipo de sistema.

130  if ogIsEfiActive; then

131  BOOTLABEL=$(printf "Part-%02d-%02d" $1 $2)

132  # Obtener parcición EFI.

133  read -e EFIDISK EFIPART <<<"$(ogGetEsp)"

134  [ -n "$EFIPART" ] || ogRaiseError $OG_ERR_PARTITION "ESP" || return $?

135  EFIDIR=$(ogMount $EFIDISK $EFIPART) || exit $?

136  # Comprobar cargador (si no existe buscar por defecto en ESP).

137  LOADER=$(ogGetPath $EFIDIR/EFI/$BOOTLABEL/Boot/bootmgfw.efi)

138  [ -z "$LOADER" ] && BOOTLABEL=Microsoft && LOADER=$(ogGetPath $EFIDIR/EFI/Microsoft/Boot/bootmgfw.efi)

139  [ -n "$LOADER" ] || ogRaiseError $OG_ERR_NOTOS "$1 $2 ($TYPE, EFI)" || return $?

140 

141  # Crear orden de arranque (con unos valores por defecto).

142  ogNvramAddEntry $BOOTLABEL "/EFI${LOADER#*EFI}" TRUE

143  # Marcar próximo arranque y reiniciar.

144  ogNvramSetNext "$BOOTLABEL"

145  reboot

146  else

147  # Arranque BIOS: comprueba si hay un cargador de Windows.

148  for f in io.sys ntldr bootmgr; do

149  FILE="$(ogGetPath $1 $2 $f 2>/dev/null)"

150  [ -n "$FILE" ] && LOADER="$f"

151  done

152  [ -n "$LOADER" ] || ogRaiseError $OG_ERR_NOTOS "$1 $2 ($TYPE)" || return $?

153  if [ "$winboot" == "kexec" ]; then

154  # Modo de arranque en caliente (con kexec).

155  cp $OGLIB/grub4dos/* $MNTDIR # */ (Comentario Doxygen)

156  kexec -l $MNTDIR/grub.exe --append=--config-file="root (hd$[$1-1],$[$2-1]); chainloader (hd$[$1-1],$[$2-1])/$LOADER; tpm --init"

157  nohup bash -c 'sleep 2 && pkill ogclient' >/dev/null 2>&1 &

158  nohup bash -c 'sleep 3 && kexec -e' >/dev/null 2>&1 &

159  else

160  # Modo de arranque por reinicio (con reboot).

161  dd if=/dev/zero of=${MNTDIR}/ogboot.me bs=1024 count=3

162  dd if=/dev/zero of=${MNTDIR}/ogboot.firstboot bs=1024 count=3

163  dd if=/dev/zero of=${MNTDIR}/ogboot.secondboot bs=1024 count=3

164  if [ -z "$(ogGetRegistryValue $MNTDIR SOFTWARE '\Microsoft\Windows\CurrentVersion\Run\ogcleannboot')" ]; then

165  ogAddRegistryValue $MNTDIR SOFTWARE '\Microsoft\Windows\CurrentVersion\Run\ogcleanboot'

166  ogSetRegistryValue $MNTDIR SOFTWARE '\Microsoft\Windows\CurrentVersion\Run\ogcleanboot' "cmd /c del c:\ogboot.*"

167  fi

168  # Activar la partición.

169  ogSetPartitionActive $1 $2

170  reboot

171  fi

172  fi

173  ;;

174  MacOS)

175  # Modo de arranque por reinicio.

176  # Nota: el cliente tiene que tener configurado correctamente Grub.

177  touch ${MNTDIR}/boot.mac &>/dev/null

178  reboot

179  ;;

180  GrubLoader)

181  # Reiniciar.

182  #reboot

183  ;;

184  *) ogRaiseError $OG_ERR_NOTOS "$1 $2 ${TYPE:+($TYPE)}"

185  return $?

186  ;;

187 esac

188 }

189 

190 

191 # ##

204 function ogGetWindowsName ()

205 {

206 # Variables locales.

207 local MNTDIR

208 

209 # Si se solicita, mostrar ayuda.

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

211  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_npartition" \

212  "$FUNCNAME 1 1 ==> PRACTICA-PC"

213  return

214 fi

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

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

217 

218 # Montar el sistema de archivos.

219 MNTDIR=$(ogMount $1 $2) || return $?

220 

221 # Obtener dato del valor de registro.

222 ogGetRegistryValue $MNTDIR system '\ControlSet001\Control\ComputerName\ComputerName\ComputerName'

223 }

224 

225 

226 # ##

249 function ogLinuxBootParameters ()

250 {

251 # Variables locales.

252 local MNTDIR CONFDIR CONFFILE f

253 

254 # Si se solicita, mostrar ayuda.

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

256  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_nfilesys" \

257  "$FUNCNAME 1 2 ==> /vmlinuz-3.5.0-21-generic /initrd.img-3.5.0-21-generic root=/dev/sda2 ro splash"

258  return

259 fi

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

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

262 

263 # Detectar id. de tipo de partición y codificar al mnemonico.

264 MNTDIR=$(ogMount $1 $2) || return $?

265 

266 # Fichero de configuración de GRUB.

267 CONFDIR=$MNTDIR # Sistema de archivos de arranque (/boot).

268 [ -d $MNTDIR/boot ] && CONFDIR=$MNTDIR/boot # Sist. archivos raíz con directorio boot.

269 for f in $MNTDIR/{,boot/}{{grubMBR,grubPARTITION}/boot/,}{grub{2,},{,efi/}EFI/*}/{menu.lst,grub.cfg}; do

270  [ -r $f ] && CONFFILE=$f

271 done

272 [ -n "$CONFFILE" ] || ogRaiseError $OG_ERR_NOTFOUND "grub.cfg" || return $?

273 

274 # Toma del fichero de configuracion los valores del kernel, initrd

275 # y parámetros de arranque usando las cláusulas por defecto

276 # ("default" en GRUB1, "set default" en GRUB2)

277 # y los formatea para que sean compatibles con \c kexec . */

278 # /* (comentario Doxygen)

279 awk 'BEGIN {cont=-1;}

280  $1~/^default$/ {sub(/=/," "); def=$2;}

281  $1~/^set$/ && $2~/^default/ { gsub(/[="]/," "); def=$3;

282  if (def ~ /saved_entry/) def=0;

283  }

284  $1~/^(title|menuentry)$/ {cont++}

285  $1~/^set$/ && $2~/^root=.\(hd'$[1-1]',(msdos|gpt)'$2'\).$/ { if (def==0) def=cont; }

286  $1~/^(kernel|linux(16|efi)?)$/ { if (def==cont) {

287  kern=$2;

288  sub($1,""); sub($1,""); sub(/^[ \t]*/,""); app=$0

289  } # /* (comentario Doxygen)

290  }

291  $1~/^initrd(16|efi)?$/ {if (def==cont) init=$2}

292  END {if (kern!="") printf("%s %s %s", kern,init,app)}

293  ' $CONFFILE

294 # */ (comentario Doxygen)

295 }

296 

297 

298 # ##

316 function ogSetWindowsName ()

317 {

318 # Variables locales.

319 local PART MNTDIR NAME

320 

321 # Si se solicita, mostrar ayuda.

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

323  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_filesys str_name" \

324  "$FUNCNAME 1 1 PRACTICA-PC"

325  return

326 fi

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

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

329 # Error si el nombre supera los 15 caracteres.

330 [ ${#3} -le 15 ] || ogRaiseError $OG_ERR_OUTOFLIMIT "\"${3:0:15}...\"" || return $?

331 

332 # Montar el sistema de archivos.

333 MNTDIR=$(ogMount $1 $2) || return $?

334 

335 # Asignar nombre.

336 NAME="$3"

337 

338 # Modificar datos de los valores de registro.

339 ogSetRegistryValue $MNTDIR system '\ControlSet001\Control\ComputerName\ComputerName\ComputerName' "$NAME" 2>/dev/null

340 ogSetRegistryValue $MNTDIR system '\ControlSet001\Services\Tcpip\Parameters\Hostname' "$NAME" 2>/dev/null

341 ogSetRegistryValue $MNTDIR system '\ControlSet001\Services\Tcpip\Parameters\HostName' "$NAME" 2>/dev/null

342 ogSetRegistryValue $MNTDIR system '\ControlSet001\services\Tcpip\Parameters\Hostname' "$NAME" 2>/dev/null

343 ogSetRegistryValue $MNTDIR system '\ControlSet001\Services\Tcpip\Parameters\NV Hostname' "$NAME" 2>/dev/null

344 ogSetRegistryValue $MNTDIR system '\ControlSet001\Services\Tcpip\Parameters\NV HostName' "$NAME" 2>/dev/null

345 ogSetRegistryValue $MNTDIR system '\ControlSet001\services\Tcpip\Parameters\NV Hostname' "$NAME" 2>/dev/null

346 }

347 

348 

349 # ##

363 function ogSetWinlogonUser ()

364 {

365 # Variables locales.

366 local PART MNTDIR NAME

367 

368 # Si se solicita, mostrar ayuda.

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

370  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_npartition str_username" \

371  "$FUNCNAME 1 1 USUARIO"

372  return

373 fi

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

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

376 

377 # Montar el sistema de archivos.

378 MNTDIR=$(ogMount $1 $2) || return $?

379 

380 # Asignar nombre.

381 NAME="$3"

382 

383 # Modificar datos en el registro.

384 ogSetRegistryValue $MNTDIR SOFTWARE '\Microsoft\Windows NT\CurrentVersion\Winlogon\DefaultUserName' "$3"

385 }

386 

387 

388 # ##

399 

400 function ogBootMbrXP ()

401 {

402 # Variables locales.

403 local DISK

404 

405 # Si se solicita, mostrar ayuda.

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

407  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk " \

408  "$FUNCNAME 1"

409  return

410 fi

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

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

413 

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

415 ms-sys -z -f $DISK

416 ms-sys -m -f $DISK

417 }

418 

419 

420 # ##

431 

432 function ogBootMbrGeneric ()

433 {

434 # Variables locales.

435 local DISK

436 

437 # Si se solicita, mostrar ayuda.

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

439  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk " \

440  "$FUNCNAME 1 "

441  return

442 fi

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

444 [ $# == 1 ] || return $(ogRaiseError $OG_ERR_FORMAT; echo $?)

445 

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

447 ms-sys -z -f $DISK

448 ms-sys -s -f $DISK

449 

450 # Firma necesaria para Windows equipos UEFI

451 SIGNATURE=0x$(cat /proc/sys/kernel/random/uuid | cut -d '-' -f1)

452 ms-sys -S $SIGNATURE $DISK

453 }

454 

455 

456 

457 

458 # ##

470 

471 function ogFixBootSector ()

472 {

473 # Variables locales.

474 local PARTYPE DISK PART FILE

475 

476 # Si se solicita, mostrar ayuda.

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

478  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_partition " \

479  "$FUNCNAME 1 1 "

480  return

481 fi

482 

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

484 [ $# == 2 ] || return $(ogRaiseError $OG_ERR_FORMAT; echo $?)

485 

486 #TODO, solo si la particion existe

487 #TODO, solo si es ntfs o fat

488 PARTYPE=$(ogGetPartitionId $1 $2)

489 case "$PARTYPE" in

490  1|4|6|7|b|c|e|f|17|700|EF00)

491  ;;

492  *)

493  return $(ogRaiseError $OG_ERR_PARTITION; echo $?)

494  ;;

495 esac

496 

497 ogUnmount $1 $2 || return $(ogRaiseError $OG_ERR_PARTITION; echo $?)

498 

499 #Preparando instruccion

500 let DISK=$1-1

501 PART=$2

502 FILE=/tmp/temp$$

503 cat > $FILE <<EOF

504 disk=$DISK

505 main_part=$PART

506 fix_first_sector=yes

507 EOF

508 

509 timeout --foreground --signal=SIGKILL 5s spartlnx.run -cui -nm -a -f $FILE

510 rm -f $FILE

511 }

512 

513 

514 # ##

525 function ogGetBootMbr ()

526 {

527 # Variables locales.

528 local DISK

529 

530 # Si se solicita, mostrar ayuda.

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

532  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk " \

533  "$FUNCNAME 1"

534  return

535 fi

536 

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

538 [ $# == 1 ] || ogRaiseError $OG_ERR_FORMAT "$FUNCNAME int_ndisk" || return $?

539 

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

541 

542 ms-sys -f $DISK

543 }

544 

545 # ##

569 

570 function ogWindowsBootParameters ()

571 {

572 # Variables locales.

573 local PART DISK BOOTLABEL BCDFILE BOOTDISK BOOTPART FILE WINVER MOUNT

574 

575 # Si se solicita, mostrar ayuda.

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

577  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_partition " \

578  "$FUNCNAME 1 1 "

579  return

580 fi

581 

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

583 [ $# == 2 ] || return $(ogRaiseError $OG_ERR_FORMAT; echo $?)

584 

585 ogDiskToDev $1 $2 || return $(ogRaiseError $OG_ERR_PARTITION; echo $?)

586 

587 #Preparando variables adaptadas a sintaxis windows.

588 let DISK=$1-1

589 PART=$2

590 FILE=/tmp/temp$$

591 if ogIsEfiActive; then

592  read BOOTDISK BOOTPART <<< $(ogGetEsp)

593  ogUnmount $BOOTDISK $BOOTPART || ogRaiseError $OG_ERR_PARTITION "ESP: $BOOTDISK $BOOTPART" || return $?

594 

595  let BOOTDISK=$BOOTDISK-1

596  BOOTLABEL=$(printf "Part-%02d-%02d" $1 $2)

597  BCDFILE="boot_BCD_file=/EFI/$BOOTLABEL/Boot/BCD"

598 else

599  BOOTDISK=$DISK

600  BOOTPART=$PART

601  BCDFILE=""

602 fi

603 

604 

605 # Obtener versión de Windows.

606 WINVER=$(ogGetOsVersion $1 $2 | awk -F"[: ]" '$1=="Windows" {if ($3=="Server") print $2,$3,$4; else print $2,$3;}')

607 [ -z "$WINVER" ] && return $(ogRaiseError $OG_ERR_NOTOS "Windows"; echo $?)

608 

609 # Acciones para Windows XP.

610 if [[ "$WINVER" =~ "XP" ]]; then

611  MOUNT=$(ogMount $1 $2)

612  [ -f ${MOUNT}/boot.ini ] || return $(ogRaiseError $OG_ERR_NOTFOUND "boot.ini"; echo $?)

613  cat ${MOUNT}/boot.ini | sed s/partition\([0-9]\)/partition\($PART\)/g | sed s/rdisk\([0-9]\)/rdisk\($DISK\)/g > ${MOUNT}/tmp.boot.ini; mv ${MOUNT}/tmp.boot.ini ${MOUNT}/boot.ini

614  return 0

615 fi

616 

617 ogUnmount $1 $2 || return $(ogRaiseError $OG_ERR_PARTITION; echo $?)

618 

619 

620 #Preparando instruccion Windows Resume Application

621 cat > $FILE <<EOF

622 boot_disk=$BOOTDISK

623 boot_main_part=$BOOTPART

624 $BCDFILE

625 disk=$DISK

626 main_part=$PART

627 boot_entry=Windows Resume Application

628 EOF

629 timeout --foreground --signal=SIGKILL 5s spartlnx.run -cui -nm -w -f $FILE

630 

631 

632 #Preparando instruccion tipo windows

633 cat > $FILE <<EOF

634 boot_disk=$BOOTDISK

635 boot_main_part=$BOOTPART

636 $BCDFILE

637 disk=$DISK

638 main_part=$PART

639 boot_entry=$WINVER

640 EOF

641 timeout --foreground --signal=SIGKILL 5s spartlnx.run -cui -nm -w -f $FILE

642 

643 ##Preparando instruccion Ramdisk Options

644 cat > $FILE <<EOF

645 boot_disk=$BOOTDISK

646 boot_main_part=$BOOTPART

647 $BCDFILE

648 disk=$DISK

649 main_part=$PART

650 boot_entry=Ramdisk Options

651 EOF

652 timeout --foreground --signal=SIGKILL 5s spartlnx.run -cui -nm -w -f $FILE

653 

654 ##Preparando instruccion Recovery Environment

655 cat > $FILE <<EOF

656 boot_disk=$BOOTDISK

657 boot_main_part=$BOOTPART

658 $BCDFILE

659 disk=$DISK

660 main_part=$PART

661 boot_entry=Windows Recovery Environment

662 EOF

663 timeout --foreground --signal=SIGKILL 5s spartlnx.run -cui -nm -w -f $FILE

664 

665 ##Preparando instruccion Recovery

666 cat > $FILE <<EOF

667 boot_disk=$BOOTDISK

668 boot_main_part=$BOOTPART

669 $BCDFILE

670 disk=$DISK

671 main_part=$PART

672 boot_entry=Windows Recovery

673 EOF

674 timeout --foreground --signal=SIGKILL 5s spartlnx.run -cui -nm -w -f $FILE

675 

676 #Preparando instruccion Windows Boot Manager

677 cat > $FILE <<EOF

678 boot_disk=$BOOTDISK

679 boot_main_part=$BOOTPART

680 $BCDFILE

681 disk=$BOOTDISK

682 main_part=$BOOTPART

683 boot_entry=Windows Boot Manager

684 EOF

685 timeout --foreground --signal=SIGKILL 5s spartlnx.run -cui -nm -w -f $FILE

686 

687 #Preparando instruccion Herramienta de diagnóstico de memoria de Windows

688 cat > $FILE <<EOF

689 boot_disk=$BOOTDISK

690 boot_main_part=$BOOTPART

691 $BCDFILE

692 disk=$BOOTDISK

693 main_part=$BOOTPART

694 boot_entry=Herramienta de diagnóstico de memoria de Windows

695 EOF

696 timeout --foreground --signal=SIGKILL 5s spartlnx.run -cui -nm -w -f $FILE

697 

698 #Preparando instruccion Herramienta de diagnóstico de memoria de Windows

699 cat > $FILE <<EOF

700 boot_disk=$BOOTDISK

701 boot_main_part=$BOOTPART

702 $BCDFILE

703 disk=$BOOTDISK

704 main_part=$BOOTPART

705 boot_entry=Herramienta de diagn<f3>stico de memoria de Windows

706 EOF

707 timeout --foreground --signal=SIGKILL 5s spartlnx.run -cui -nm -w -f $FILE

708 

709 rm -f $FILE

710 }

711 

712 

713 

714 # ##

729 function ogWindowsRegisterPartition ()

730 {

731 # Variables locales.

732 local PART DISK FILE REGISTREDDISK REGISTREDPART REGISTREDVOL VERSION SYSTEMROOT

733 

734 # Si se solicita, mostrar ayuda.

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

736  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk_TO_registre int_partition_TO_registre str_NewVolume int_disk int_parition " \

737  "$FUNCNAME 1 1 c: 1 1"

738  return

739 fi

740 

741 # Error si no se reciben 5 parámetros.

742 [ $# == 5 ] || return $(ogRaiseError $OG_ERR_FORMAT; echo $?)

743 

744 REGISTREDDISK=$1

745 REGISTREDPART=$2

746 REGISTREDVOL=$(echo $3 | cut -c1 | tr '[:lower:]' '[:upper:]')

747 DISK=$4

748 PART=$5

749 FILE=/tmp/temp$$

750 

751 ogDiskToDev $REGISTREDDISK $REGISTREDPART || return $(ogRaiseError $OG_ERR_PARTITION "particion a registrar "; echo $?)

752 ogDiskToDev $DISK $PART || return $(ogRaiseError $OG_ERR_PARTITION "particion de windows"; echo $?)

753 

754 ogGetOsType $DISK $PART | grep "Windows" || return $(ogRaiseError $OG_ERR_NOTOS "no es windows"; echo $?)

755 

756 VERSION=$(ogGetOsVersion $DISK $PART)

757 

758 #Systemroot

759 

760 if ogGetPath $DISK $PART WINDOWS

761 then

762  SYSTEMROOT="Windows"

763 elif ogGetPath $DISK $PART WINNT

764 then

765  SYSTEMROOT="winnt"

766 else

767  return $(ogRaiseError $OG_ERR_NOTOS; echo $?)

768 fi

769 

770 ogUnmount $DISK $PART

771 let DISK=$DISK-1

772 let REGISTREDDISK=$REGISTREDDISK-1

773 #Preparando instruccion Windows Boot Manager

774 cat > $FILE <<EOF

775 windows_disk=$DISK

776 windows_main_part=$PART

777 windows_dir=$SYSTEMROOT

778 disk=$REGISTREDDISK

779 main_part=$REGISTREDPART

780 ;ext_part

781 part_letter=$REGISTREDVOL

782 EOF

783 timeout --foreground --signal=SIGKILL 5s spartlnx.run -cui -nm -u -f $FILE

784 

785 }

786 

787 # ##

817 

818 function ogGrubInstallMbr ()

819 {

820 

821 # Variables locales.

822 local PART DISK VERSION FIRSTAGE SECONSTAGE CHECKOS KERNELPARAM BACKUPNAME

823 local EFIDISK EFIPART EFISECONDSTAGE EFISUBDIR EFIOPTGRUB GRUBENTRY NEWORDER

824 

825 # Si se solicita, mostrar ayuda.

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

827  ogHelp "$FUNCNAME" "$FUNCNAME int_ndiskSecondStage int_partitionSecondStage bolean_Configure_2ndStage \"param param \" " \

828  "$FUNCNAME 1 1 FALSE " \

829  "$FUNCNAME 1 1 TRUE \"nomodeset irqpoll pci=noacpi quiet splash \" "

830  return

831 fi

832 

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

834 [ $# -ge 2 ] || return $(ogRaiseError $OG_ERR_FORMAT; echo $?)

835 

836 

837 DISK=$1; PART=$2;

838 CHECKOS=${3:-"FALSE"}

839 KERNELPARAM=$4

840 BACKUPNAME=".backup.og"

841 

842 #Error si no es linux.

843 #TODO: comprobar si se puede utilizar la particion windows como contenedor de grub.

844 #VERSION=$(ogGetOsVersion $DISK $PART)

845 #echo $VERSION | grep "Linux" || return $(ogRaiseError $OG_ERR_NOTOS "no es linux"; echo $?)

846 

847 #La primera etapa del grub se fija en el primer disco duro

848 FIRSTSTAGE=$(ogDiskToDev 1)

849 

850 #localizar disco segunda etapa del grub

851 SECONDSTAGE=$(ogMount "$DISK" "$PART") || return $?

852 

853 # prepara el directorio principal de la segunda etapa

854 [ -d ${SECONDSTAGE}/boot/grub/ ] || mkdir -p ${SECONDSTAGE}/boot/grub/

855 

856 #Localizar directorio segunda etapa del grub

857 PREFIXSECONDSTAGE="/boot/grubMBR"

858 

859 # Instalamos grub para EFI en ESP

860 EFIOPTGRUB=""

861 if ogIsEfiActive; then

862  read EFIDISK EFIPART <<< $(ogGetEsp)

863  # Comprobamos que exista ESP y el directorio para ubuntu

864  EFISECONDSTAGE=$(ogMount $EFIDISK $EFIPART)

865  if [ $? -ne 0 ]; then

866  ogFormat $EFIDISK $EFIPART FAT32

867  EFISECONDSTAGE=$(ogMount $EFIDISK $EFIPART) || ogRaiseError $OG_ERR_PARTITION "ESP" || return $?

868  fi

869  EFISUBDIR="grub"

870  # Borramos la configuración anterior

871  [ -d ${EFISECONDSTAGE}/EFI/$EFISUBDIR ] && rm -rf ${EFISECONDSTAGE}/EFI/$EFISUBDIR

872  mkdir -p ${EFISECONDSTAGE}/EFI/$EFISUBDIR/Boot

873  EFIOPTGRUB=" --removable --no-nvram --uefi-secure-boot --target $(ogGetArch)-efi --efi-directory=${EFISECONDSTAGE}/EFI/$EFISUBDIR "

874 fi

875 

876 # Si Reconfigurar segunda etapa (grub.cfg) == FALSE

877 if [ "${CHECKOS^^}" == "FALSE" ] && [ -f ${SECONDSTAGE}/boot/grub/grub.cfg -o -f ${SECONDSTAGE}/boot/grub/grub.cfg$BACKUPNAME ]

878 then

879  # Si no se reconfigura se utiliza el grub.cfg orginal

880  [ -f ${SECONDSTAGE}/boot/grub/grub.cfg$BACKUPNAME ] && mv ${SECONDSTAGE}/boot/grub/grub.cfg$BACKUPNAME ${SECONDSTAGE}/boot/grub/grub.cfg

881  # Si no se reconfigure se borra los ficheros previos de configuración específicos de opengnsys.

882  [ -d ${SECONDSTAGE}${PREFIXSECONDSTAGE} ] && rm -fr ${SECONDSTAGE}${PREFIXSECONDSTAGE}

883  PREFIXSECONDSTAGE=""

884 else

885  # SI Reconfigurar segunda etapa (grub.cfg) == TRUE

886 

887  #llamada a updateBootCache para que aloje la primera fase del ogLive

888  updateBootCache

889 

890  if ogIsEfiActive; then

891  # UEFI: grubSintax necesita grub.cfg para detectar los kernels: si no existe recupero backup.

892  if ! [ -f ${SECONDSTAGE}/boot/grub/grub.cfg ]; then

893  [ -f ${SECONDSTAGE}/boot/grub/grub.cfg$BACKUPNAME ] && mv ${SECONDSTAGE}/boot/grub/grub.cfg$BACKUPNAME ${SECONDSTAGE}/boot/grub/grub.cfg

894  fi

895  else

896  #Evitar detectar modo recovery - mover grub.cfg original a grub.cfg.backup

897  mv ${SECONDSTAGE}/boot/grub/grub.cfg ${SECONDSTAGE}/boot/grub/grub.cfg$BACKUPNAME

898  fi

899 

900  #Configur la sintaxis grub para evitar menus de "recovery" en el OGLive

901  echo "GRUB_DISABLE_RECOVERY=\"true\"" >> /etc/default/grub

902  echo "GRUB_DISABLE_LINUX_UUID=\"true\"" >> /etc/default/grub

903 

904 

905  #Preparar configuración segunda etapa: crear ubicacion

906  mkdir -p ${SECONDSTAGE}${PREFIXSECONDSTAGE}/boot/grub/

907  #Preparar configuración segunda etapa: crear cabecera del fichero (ignorar errores)

908  sed -i 's/^set -e/#set -e/' /etc/grub.d/00_header

909  # (ogLive 5.0) Si 'pkgdatadir' está vacía ponemos valor de otros ogLive

910  sed -i '/grub-mkconfig_lib/i\pkgdatadir=${pkgdatadir:-"${datarootdir}/grub"}' /etc/grub.d/00_header

911  /etc/grub.d/00_header > ${SECONDSTAGE}${PREFIXSECONDSTAGE}/boot/grub/grub.cfg 2>/dev/null

912 

913  #Preparar configuración segunda etapa: crear entrada del sistema operativo

914  grubSyntax "$KERNELPARAM" >> ${SECONDSTAGE}${PREFIXSECONDSTAGE}/boot/grub/grub.cfg

915 

916  # Renombramos la configuración de grub antigua

917  [ -f ${SECONDSTAGE}/boot/grub/grub.cfg ] && mv ${SECONDSTAGE}/boot/grub/grub.cfg ${SECONDSTAGE}/boot/grub/grub.cfg$BACKUPNAME

918 

919 fi

920 

921 #Instalar el grub

922 grub-install --force ${EFIOPTGRUB} --root-directory=${SECONDSTAGE}${PREFIXSECONDSTAGE} $FIRSTSTAGE

923 EVAL=$?

924 

925 # Movemos el grubx64.efi

926 if ogIsEfiActive; then

927  mv ${EFISECONDSTAGE}/EFI/$EFISUBDIR/EFI/BOOT/* ${EFISECONDSTAGE}/EFI/$EFISUBDIR/Boot

928  rm -rf ${EFISECONDSTAGE}/EFI/$EFISUBDIR/EFI

929  cp /usr/lib/shim/shimx64.efi.signed ${EFISECONDSTAGE}/EFI/$EFISUBDIR/Boot/shimx64.efi

930  # Nombre OpenGnsys para cargador

931  cp ${EFISECONDSTAGE}/EFI/$EFISUBDIR/Boot/{grubx64.efi,ogloader.efi}

932 

933  # Creamos entrada NVRAM y la ponemos en segundo lugar

934  ogNvramAddEntry grub /EFI/grub/Boot/shimx64.efi

935  GRUBENTRY=$(ogNvramList| awk '{if ($2=="grub") print $1}')

936  NEWORDER="$(ogNvramGetOrder|awk -v ENTRY=$GRUBENTRY '{gsub(",", " "); printf "%x %x %s\n", $1 , ENTRY , substr($0, index($0,$2))}')"

937  ogNvramSetOrder $NEWORDER

938 fi

939 return $EVAL

940 

941 }

942 

943 

944 # ##

969 

970 function ogGrubInstallPartition ()

971 {

972 

973 # Variables locales.

974 local PART DISK VERSION FIRSTAGE SECONSTAGE CHECKOS KERNELPARAM BACKUPNAME

975 local EFIDISK EFIPART EFISECONDSTAGE EFISUBDIR EFIOPTGRUB EFIBOOTDIR

976 

977 # Si se solicita, mostrar ayuda.

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

979  ogHelp "$FUNCNAME" "$FUNCNAME int_ndiskSecondStage int_partitionSecondStage bolean_Configure_2ndStage \"param param \" " \

980  "$FUNCNAME 1 1 FALSE " \

981  "$FUNCNAME 1 1 TRUE \"nomodeset irqpoll pci=noacpi quiet splash \" "

982  return

983 fi

984 

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

986 [ $# -ge 2 ] || return $(ogRaiseError $OG_ERR_FORMAT; echo $?)

987 

988 DISK=$1; PART=$2;

989 CHECKOS=${3:-"FALSE"}

990 KERNELPARAM=$4

991 BACKUPNAME=".backup.og"

992 

993 #error si no es linux.

994 VERSION=$(ogGetOsVersion $DISK $PART)

995 echo $VERSION | grep "Linux" || return $(ogRaiseError $OG_ERR_NOTOS "no es linux"; echo $?)

996 

997 #Localizar primera etapa del grub

998 FIRSTSTAGE=$(ogDiskToDev $DISK $PART)

999 

1000 #localizar disco segunda etapa del grub

1001 SECONDSTAGE=$(ogMount $DISK $PART)

1002 

1003 #Localizar directorio segunda etapa del grub

1004 PREFIXSECONDSTAGE="/boot/grubPARTITION"

1005 

1006 # Si es EFI instalamos el grub en la ESP

1007 EFIOPTGRUB=""

1008 # Desde el bootdir uefi y bios buscan el grub.cfg en subdirectorios distintos.

1009 EFIBOOTDIR=""

1010 if ogIsEfiActive; then

1011  read EFIDISK EFIPART <<< $(ogGetEsp)

1012  # Comprobamos que exista ESP y el directorio para ubuntu

1013  EFISECONDSTAGE=$(ogMount $EFIDISK $EFIPART)

1014  if [ $? -ne 0 ]; then

1015  ogFormat $EFIDISK $EFIPART FAT32

1016  EFISECONDSTAGE=$(ogMount $EFIDISK $EFIPART) || ogRaiseError $OG_ERR_PARTITION "ESP" || return $?

1017  fi

1018  EFISUBDIR=$(printf "Part-%02d-%02d" $DISK $PART)

1019  # Borramos la configuración anterior

1020  [ -d ${EFISECONDSTAGE}/EFI/$EFISUBDIR ] && rm -rf ${EFISECONDSTAGE}/EFI/$EFISUBDIR

1021  mkdir -p ${EFISECONDSTAGE}/EFI/$EFISUBDIR/Boot

1022  EFIOPTGRUB=" --removable --no-nvram --uefi-secure-boot --target $(ogGetArch)-efi --efi-directory=${EFISECONDSTAGE}/EFI/$EFISUBDIR "

1023  EFIBOOTDIR="/boot"

1024 fi

1025 

1026 # Si Reconfigurar segunda etapa (grub.cfg) == FALSE

1027 if [ "${CHECKOS^^}" == "FALSE" ] && [ -f ${SECONDSTAGE}/boot/grub/grub.cfg -o -f ${SECONDSTAGE}/boot/grub/grub.cfg$BACKUPNAME ]

1028 then

1029  # Si no se reconfigura se utiliza el grub.cfg orginal

1030  [ -f ${SECONDSTAGE}/boot/grub/grub.cfg$BACKUPNAME ] && mv ${SECONDSTAGE}/boot/grub/grub.cfg$BACKUPNAME ${SECONDSTAGE}/boot/grub/grub.cfg

1031  # Si no se reconfigure se borra los ficheros previos de configuración específicos de opengnsys.

1032  [ -d ${SECONDSTAGE}${PREFIXSECONDSTAGE} ] && rm -fr ${SECONDSTAGE}${PREFIXSECONDSTAGE}

1033  # Reactivamos el grub con el grub.cfg original.

1034  PREFIXSECONDSTAGE=""

1035 else

1036  # SI Reconfigurar segunda etapa (grub.cfg) == TRUE

1037 

1038  if ogIsEfiActive; then

1039  # UEFI: grubSintax necesita grub.cfg para detectar los kernels: si no existe recupero backup.

1040  if ! [ -f ${SECONDSTAGE}/boot/grub/grub.cfg ]; then

1041  [ -f ${SECONDSTAGE}/boot/grub/grub.cfg$BACKUPNAME ] && mv ${SECONDSTAGE}/boot/grub/grub.cfg$BACKUPNAME ${SECONDSTAGE}/boot/grub/grub.cfg

1042  fi

1043  else

1044  #Evitar detectar modo recovery - mover grub.cfg original a grub.cfg.backup

1045  mv ${SECONDSTAGE}/boot/grub/grub.cfg ${SECONDSTAGE}/boot/grub/grub.cfg$BACKUPNAME

1046  fi

1047 

1048  #Configur la sintaxis grub para evitar menus de "recovery" en el OGLive

1049  echo "GRUB_DISABLE_RECOVERY=\"true\"" >> /etc/default/grub

1050  echo "GRUB_DISABLE_LINUX_UUID=\"true\"" >> /etc/default/grub

1051 

1052  #Preparar configuración segunda etapa: crear ubicacion

1053  mkdir -p ${SECONDSTAGE}${PREFIXSECONDSTAGE}/boot/grub/

1054  #Preparar configuración segunda etapa: crear cabecera del fichero (ingnorar errores)

1055  sed -i 's/^set -e/#set -e/' /etc/grub.d/00_header

1056  # (ogLive 5.0) Si 'pkgdatadir' está vacía ponemos valor de otros ogLive

1057  sed -i '/grub-mkconfig_lib/i\pkgdatadir=${pkgdatadir:-"${datarootdir}/grub"}' /etc/grub.d/00_header

1058  /etc/grub.d/00_header > ${SECONDSTAGE}${PREFIXSECONDSTAGE}/boot/grub/grub.cfg 2>/dev/null

1059  #Preparar configuración segunda etapa: crear entrada del sistema operativo

1060  grubSyntax $DISK $PART "$KERNELPARAM" >> ${SECONDSTAGE}${PREFIXSECONDSTAGE}/boot/grub/grub.cfg

1061 

1062 fi

1063 #Instalar el grub

1064 grub-install --force ${EFIOPTGRUB} --root-directory=${SECONDSTAGE}${PREFIXSECONDSTAGE} $FIRSTSTAGE

1065 EVAL=$?

1066 

1067 # Movemos el grubx64.efi

1068 if ogIsEfiActive; then

1069  mv ${EFISECONDSTAGE}/EFI/$EFISUBDIR/EFI/BOOT/* ${EFISECONDSTAGE}/EFI/$EFISUBDIR/Boot

1070  rm -rf ${EFISECONDSTAGE}/EFI/$EFISUBDIR/EFI

1071  cp /usr/lib/shim/shimx64.efi.signed ${EFISECONDSTAGE}/EFI/$EFISUBDIR/Boot/shimx64.efi

1072  # Nombre OpenGnsys para cargador

1073  cp ${EFISECONDSTAGE}/EFI/$EFISUBDIR/Boot/{grubx64.efi,ogloader.efi}

1074 fi

1075 

1076 return $EVAL

1077 }

1078 

1079 

1080 # ##

1099 function ogConfigureFstab ()

1100 {

1101 # Variables locales.

1102 local FSTAB DEFROOT PARTROOT DEFSWAP PARTSWAP

1103 local EFIDISK EFIPART EFIDEV EFIOPT

1104 

1105 # Si se solicita, mostrar ayuda.

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

1107  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_nfilesys" \

1108  "$FUNCNAME 1 1"

1109  return

1110 fi

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

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

1113 # Error si no se encuentra un fichero etc/fstab en el sistema de archivos.

1114 FSTAB=$(ogGetPath $1 $2 /etc/fstab) 2>/dev/null

1115 [ -n "$FSTAB" ] || ogRaiseError $OG_ERR_NOTFOUND "$1,$2,/etc/fstab" || return $?

1116 

1117 # Hacer copia de seguridad del fichero fstab original.

1118 cp -a ${FSTAB} ${FSTAB}.backup

1119 # Dispositivo del raíz en fichero fstab: 1er campo (si no tiene "#") con 2º campo = "/".

1120 DEFROOT=$(awk '$1!~/#/ && $2=="/" {print $1}' ${FSTAB})

1121 PARTROOT=$(ogDiskToDev $1 $2)

1122 # Configuración de swap (solo 1ª partición detectada).

1123 PARTSWAP=$(blkid -t TYPE=swap | awk -F: 'NR==1 {print $1}')

1124 if [ -n "$PARTSWAP" ]

1125 then

1126  # Dispositivo de swap en fichero fstab: 1er campo (si no tiene "#") con 3er campo = "swap".

1127  DEFSWAP=$(awk '$1!~/#/ && $3=="swap" {print $1}' ${FSTAB})

1128  if [ -n "$DEFSWAP" ]

1129  then

1130  echo "Hay definicion de SWAP en el FSTAB $DEFSWAP -> modificamos fichero con nuevo valor $DEFSWAP->$PARTSWAP" # Mensaje temporal.

1131  sed "s|$DEFSWAP|$PARTSWAP|g ; s|$DEFROOT|$PARTROOT|g" ${FSTAB}.backup > ${FSTAB}

1132  else

1133  echo "No hay definicion de SWAP y si hay partición SWAP -> moficamos fichero" # Mensaje temporal.

1134  sed "s|$DEFROOT|$PARTROOT|g" ${FSTAB}.backup > ${FSTAB}

1135  echo "$PARTSWAP none swap sw 0 0" >> ${FSTAB}

1136  fi

1137 else

1138  echo "No hay partición SWAP -> configuramos FSTAB" # Mensaje temporal.

1139  sed "/swap/d" ${FSTAB}.backup > ${FSTAB}

1140 fi

1141 # Si es un sistema EFI incluimos partición ESP (Si existe la modificamos)

1142 if ogIsEfiActive; then

1143  read EFIDISK EFIPART <<< $(ogGetEsp)

1144  EFIDEV=$(ogDiskToDev $EFIDISK $EFIPART)

1145 

1146  # Opciones de la partición ESP: si no existe ponemos un valor por defecto

1147  EFIOPT=$(awk '$1!~/#/ && $2=="/boot/efi" {print $3"\t"$4"\t"$5"\t"$6 }' ${FSTAB})

1148  [ "$EFIOPT" == "" ] && EFIOPT='vfat\tumask=0077\t0\t1'

1149 

1150  sed -i /"boot\/efi"/d ${FSTAB}

1151  echo -e "$EFIDEV\t/boot/efi\t$EFIOPT" >> ${FSTAB}

1152 fi

1153 }

1154 

1155 # ##

1170 function ogSetLinuxName ()

1171 {

1172 # Variables locales.

1173 local MNTDIR ETC NAME

1174 

1175 # Si se solicita, mostrar ayuda.

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

1177  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_nfilesys [str_name]" \

1178  "$FUNCNAME 1 1" "$FUNCNAME 1 1 practica-pc"

1179  return

1180 fi

1181 # Error si no se reciben 2 o 3 parámetros.

1182 case $# in

1183  2) # Asignar nombre automático (por defecto, "pc").

1184  NAME="$(ogGetHostname)"

1185  NAME=${NAME:-"pc"} ;;

1186  3) # Asignar nombre del 3er parámetro.

1187  NAME="$3" ;;

1188  *) # Formato de ejecución incorrecto.

1189  ogRaiseError $OG_ERR_FORMAT

1190  return $?

1191 esac

1192 

1193 # Montar el sistema de archivos.

1194 MNTDIR=$(ogMount $1 $2) || return $?

1195 

1196 ETC=$(ogGetPath $1 $2 /etc)

1197 

1198 if [ -d "$ETC" ]; then

1199  #cambio de nombre en hostname

1200  echo "$NAME" > $ETC/hostname

1201  #Opcion A para cambio de nombre en hosts

1202  #sed "/127.0.1.1/ c\127.0.1.1 \t $HOSTNAME" $ETC/hosts > /tmp/hosts && cp /tmp/hosts $ETC/ && rm /tmp/hosts

1203  #Opcion B componer fichero de hosts

1204  cat > $ETC/hosts <<EOF

1205 127.0.0.1 localhost

1206 127.0.1.1 $NAME

1207 

1208 # The following lines are desirable for IPv6 capable hosts

1209 ::1 ip6-localhost ip6-loopback

1210 fe00::0 ip6-localnet

1211 ff00::0 ip6-mcastprefix

1212 ff02::1 ip6-allnodes

1213 ff02::2 ip6-allrouters

1214 EOF

1215 fi

1216 }

1217 

1218 

1219 

1220 # ##

1236 function ogCleanLinuxDevices ()

1237 {

1238 # Variables locales.

1239 local MNTDIR

1240 

1241 # Si se solicita, mostrar ayuda.

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

1243  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_nfilesys" \

1244  "$FUNCNAME 1 1"

1245  return

1246 fi

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

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

1249 

1250 # Montar el sistema de archivos.

1251 MNTDIR=$(ogMount $1 $2) || return $?

1252 

1253 # Eliminar fichero de configuración de udev para dispositivos fijos de red.

1254 [ -f ${MNTDIR}/etc/udev/rules.d/70-persistent-net.rules ] && rm -f ${MNTDIR}/etc/udev/rules.d/70-persistent-net.rules

1255 # Eliminar fichero resume (estado previo de hibernación) utilizado por el initrd scripts-premount

1256 [ -f ${MNTDIR}/etc/initramfs-tools/conf.d/resume ] && rm -f ${MNTDIR}/etc/initramfs-tools/conf.d/resume

1257 }

1258 

1259 # ##

1278 

1279 

1280 function ogGrubAddOgLive ()

1281 {

1282  local TIMEOUT DIRMOUNT GRUBGFC PARTTABLETYPE NUMDISK NUMPART KERNEL STATUS NUMLINE MENUENTRY

1283 

1284  # Si se solicita, mostrar ayuda.

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

1286  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_npartition [ time_out ] [ offline|online ] " \

1287  "$FUNCNAME 1 1" \

1288  "$FUNCNAME 1 6 15 offline"

1289  return

1290  fi

1291 

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

1293  [ $# -lt 2 ] && return $(ogRaiseError session $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME num_disk num_part [ timeout ]"; echo $?)

1294  [[ "$3" =~ ^[0-9]*$ ]] && TIMEOUT="$3"

1295 

1296  # Error si no existe el kernel y el initrd en la cache.

1297  # Falta crear nuevo codigo de error.

1298  [ -r $OGCAC/boot/${oglivedir}/ogvmlinuz -a -r $OGCAC/boot/${oglivedir}/oginitrd.img ] || return $(ogRaiseError log session $OG_ERR_NOTFOUND "CACHE: ogvmlinuz, oginitrd.img" 1>&2; echo $?)

1299 

1300  # Archivo de configuracion del grub

1301  DIRMOUNT=$(ogMount $1 $2)

1302  GRUBGFC="$DIRMOUNT/boot/grubMBR/boot/grub/grub.cfg"

1303 

1304  # Error si no existe archivo del grub

1305  [ -r $GRUBGFC ] || return $(ogRaiseError log session $OG_ERR_NOTFOUND "$GRUBGFC" 1>&2; echo $?)

1306 

1307  # Si existe la entrada de opengnsys, se borra

1308  grep -q "menuentry Opengnsys" $GRUBGFC && sed -ie "/menuentry Opengnsys/,+6d" $GRUBGFC

1309 

1310  # Tipo de tabla de particiones

1311  PARTTABLETYPE=$(ogGetPartitionTableType $1 | tr [:upper:] [:lower:])

1312 

1313  # Localizacion de la cache

1314  read NUMDISK NUMPART <<< $(ogFindCache)

1315  let NUMDISK=$NUMDISK-1

1316  # kernel y sus opciones. Pasamos a modo usuario

1317  KERNEL="/boot/${oglivedir}/ogvmlinuz $(sed -e s/^.*linuz//g -e s/ogactiveadmin=[a-z]*//g /proc/cmdline)"

1318 

1319  # Configuracion offline si existe parametro

1320  echo "$@" |grep offline &>/dev/null && STATUS=offline

1321  echo "$@" |grep online &>/dev/null && STATUS=online

1322  [ -z "$STATUS" ] || KERNEL="$(echo $KERNEL | sed s/"ogprotocol=[a-z]* "/"ogprotocol=local "/g ) ogstatus=$STATUS"

1323 

1324  # Numero de línea de la primera entrada del grub.

1325  NUMLINE=$(grep -n -m 1 "^menuentry" $GRUBGFC|cut -d: -f1)

1326  # Texto de la entrada de opengnsys

1327 MENUENTRY="menuentry "OpenGnsys" --class opengnsys --class gnu --class os { \n \

1328 \tinsmod part_$PARTTABLETYPE \n \

1329 \tinsmod ext2 \n \

1330 \tset root='(hd${NUMDISK},$PARTTABLETYPE${NUMPART})' \n \

1331 \tlinux $KERNEL \n \

1332 \tinitrd /boot/${oglivedir}/oginitrd.img \n \

1333 }"

1334 

1335 

1336  # Insertamos la entrada de opengnsys antes de la primera entrada existente.

1337  sed -i "${NUMLINE}i\ $MENUENTRY" $GRUBGFC

1338 

1339  # Ponemos que la entrada por defecto sea la primera.

1340  sed -i s/"set.*default.*$"/"set default=\"0\""/g $GRUBGFC

1341 

1342  # Si me dan valor para timeout lo cambio en el grub.

1343  [ $TIMEOUT ] && sed -i s/timeout=.*$/timeout=$TIMEOUT/g $GRUBGFC

1344 }

1345 

1346 # ##

1351 function ogGrubHidePartitions ()

1352 {

1353  # Si se solicita, mostrar ayuda.

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

1355  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_npartition [ num_disk_partdata num_partdata ]" \

1356  "$FUNCNAME 1 2" \

1357  "$FUNCNAME 1 2 1 3"

1358  return

1359  fi

1360  ogBootLoaderHidePartitions $@

1361  return $?

1362 }

1363 

1364 # ##

1369 function ogBurgHidePartitions ()

1370 {

1371  # Si se solicita, mostrar ayuda.

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

1373  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_npartition [ num_disk_partdata num_partdata ]" \

1374  "$FUNCNAME 1 2" \

1375  "$FUNCNAME 1 2 1 3"

1376  return

1377  fi

1378  ogBootLoaderHidePartitions $@

1379  return $?

1380 }

1381 

1382 #

1406 function ogBootLoaderHidePartitions ()

1407 {

1408  local FUNC DIRMOUNT GFCFILE PARTTABLETYPE WINENTRY WINPART ENTRY LINE PART PARTDATA TEXT PARTHIDDEN HIDDEN

1409 

1410  # Si se solicita, mostrar ayuda.

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

1412  ogHelp "$FUNCNAME" "$MSG_SEE ogGrubHidePartitions ogBurgHidePartitions"

1413  return

1414  fi

1415 

1416  # Nombre de la función que llama a esta.

1417  FUNC="${FUNCNAME[@]:1}"

1418  FUNC="${FUNC%%\ *}"

1419 

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

1421  [ $# -lt 2 ] && return $(ogRaiseError session $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME num_disk num_part [ num_disk_partdata num_partdata ]"; echo $?)

1422  # Si no existe $4 pongo un valor imposible para la partición de datos

1423  [ $# -eq 4 ] && PARTDATA=$(ogDiskToDev $3 $4) || PARTDATA=0

1424 

1425  # Archivo de configuracion del grub

1426  DIRMOUNT=$(ogMount $1 $2)

1427  # La función debe ser llamanda desde ogGrubHidePartitions or ogBurgHidePartitions.

1428  case "$FUNC" in

1429  ogGrubHidePartitions)

1430  CFGFILE="$DIRMOUNT/boot/grubMBR/boot/grub/grub.cfg"

1431  ;;

1432  ogBurgHidePartitions)

1433  CFGFILE="$DIRMOUNT/boot/burg/burg.cfg"

1434  ;;

1435  *)

1436  ogRaiseError $OG_ERR_FORMAT "Use ogGrubHidePartitions or ogBurgHidePartitions."

1437  return $?

1438  ;;

1439  esac

1440 

1441  # Error si no existe archivo del grub

1442  [ -r $CFGFILE ] || return $(ogRaiseError log session $OG_ERR_NOTFOUND "$CFGFILE" 1>&2; echo $?)

1443 

1444  # Si solo hay una particion de Windows me salgo

1445  [ $(fdisk -l $(ogDiskToDev) | grep 'NTFS' |wc -l) -eq 1 ] && return 0

1446 

1447  # Elimino llamadas a parttool, se han incluido en otras ejecuciones de esta funcion.

1448  sed -i '/parttool/d' $CFGFILE

1449 

1450  PARTTABLETYPE=$(ogGetPartitionTableType $1 | tr [:upper:] [:lower:])

1451 

1452 # /* (comentario de bloque para Doxygen)

1453  # Entradas de Windows: numero de linea y particion. De mayor a menor.

1454  WINENTRY=$(awk '/menuentry.*Windows/ {gsub(/\)["'"'"']/, ""); gsub(/^.*dev/,""); print NR":/dev"$1} ' $CFGFILE | sed -e '1!G;h;$!d')

1455  #*/ (comentario para bloque Doxygen)

1456  # Particiones de Windows, pueden no estar en el grub.

1457  WINPART=$(fdisk -l $(ogDiskToDev)|awk '/NTFS/ {print $1}'|sed '1!G;h;$!d')

1458 

1459 

1460  # Modifico todas las entradas de Windows.

1461  for ENTRY in $WINENTRY; do

1462  LINE=${ENTRY%:*}

1463  PART=${ENTRY#*:}

1464 

1465  # En cada entrada, oculto o muestro cada particion.

1466  TEXT=""

1467  for PARTHIDDEN in $WINPART; do

1468  # Muestro la particion de la entrada actual y la de datos.

1469  [ "$PARTHIDDEN" == "$PART" -o "$PARTHIDDEN" == "$PARTDATA" ] && HIDDEN="-" || HIDDEN="+"

1470  read NUMDISK NUMPART <<< $(ogDevToDisk $PARTHIDDEN)

1471 

1472  TEXT="\tparttool (hd$((NUMDISK-1)),$PARTTABLETYPE$NUMPART) hidden$HIDDEN \n$TEXT"

1473  done

1474 

1475  sed -i "${LINE}a\ $TEXT" $CFGFILE

1476  done

1477 

1478  # Activamos la particion que se inicia en todas las entradas de windows.

1479  sed -i "/chainloader/i\\\tparttool \$\{root\} boot+" $CFGFILE

1480 }

1481 

1482 #

1487 function ogGrubDeleteEntry ()

1488 {

1489  # Si se solicita, mostrar ayuda.

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

1491  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_npartition int_disk_delete int_npartition_delete" \

1492  "$FUNCNAME 1 6 2 1"

1493  return

1494  fi

1495  ogBootLoaderDeleteEntry $@

1496  return $?

1497 }

1498 

1499 #

1504 function ogBurgDeleteEntry ()

1505 {

1506  # Si se solicita, mostrar ayuda.

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

1508  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_npartition int_disk_delete int_npartition_delete" \

1509  "$FUNCNAME 1 6 2 1"

1510  return

1511  fi

1512  ogBootLoaderDeleteEntry $@

1513  return $?

1514 }

1515 

1516 #

1521 function ogRefindDeleteEntry ()

1522 {

1523  local EFIDISK EFIPART

1524  # Si se solicita, mostrar ayuda.

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

1526  ogHelp "$FUNCNAME" "$FUNCNAME int_disk_delete int_npartition_delete" \

1527  "$FUNCNAME 2 1"

1528  return

1529  fi

1530  read EFIDISK EFIPART <<< $(ogGetEsp)

1531  ogBootLoaderDeleteEntry $EFIDISK $EFIPART $@

1532  return $?

1533 }

1534 

1535 # ##

1551 

1552 function ogBootLoaderDeleteEntry ()

1553 {

1554  local FUNC DIRMOUNT CFGFILE LABEL MENUENTRY DELETEENTRY ENDENTRY ENTRY

1555 

1556  # Si se solicita, mostrar ayuda.

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

1558  ogHelp "$FUNCNAME" "$MSG_SEE ogBurgDeleteEntry, ogGrubDeleteEntry or ogRefindDeleteEntry"

1559  return

1560  fi

1561 

1562  # Si el número de parámetros menos que 4 nos salimos

1563  [ $# -lt 4 ] && return $(ogRaiseError session $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME num_disk num_part num_disk_delete num_part_delete"; echo $?)

1564 

1565 

1566  # Nombre de la función que llama a esta.

1567  FUNC="${FUNCNAME[@]:1}"

1568  FUNC="${FUNC%%\ *}"

1569 

1570  # Archivo de configuracion del grub

1571  DIRMOUNT=$(ogMount $1 $2)

1572  # La función debe ser llamanda desde ogGrubDeleteEntry, ogBurgDeleteEntry or ogRefindDeleteEntry.

1573  case "$FUNC" in

1574  ogGrubDeleteEntry)

1575  CFGFILE="$DIRMOUNT/boot/grubMBR/boot/grub/grub.cfg"

1576  ;;

1577  ogBurgDeleteEntry)

1578  CFGFILE="$DIRMOUNT/boot/burg/burg.cfg"

1579  ;;

1580  ogRefindDeleteEntry)

1581  CFGFILE="$DIRMOUNT/EFI/refind/refind.conf"

1582  ;;

1583  *)

1584  ogRaiseError $OG_ERR_FORMAT "Use ogGrubDeleteEntry, ogBurgDeleteEntry or ogRefindDeleteEntry."

1585  return $?

1586  ;;

1587  esac

1588 

1589  # Dispositivo

1590  if [ "$(basename $CFGFILE)" == "refind.conf" ]; then

1591  LABEL=$(printf "Part-%02d-%02d" $3 $4)

1592  else

1593  LABEL=$(ogDiskToDev $3 $4)

1594  fi

1595 

1596  # Error si no existe archivo de configuración

1597  [ -r $CFGFILE ] || ogRaiseError log session $OG_ERR_NOTFOUND "$CFGFILE" || return $?

1598 

1599  # Numero de linea de cada entrada.

1600  MENUENTRY="$(grep -n -e menuentry $CFGFILE| cut -d: -f1 | sed '1!G;h;$!d' )"

1601 

1602  # Entradas que hay que borrar.

1603  DELETEENTRY=$(grep -n menuentry.*$LABEL $CFGFILE| cut -d: -f1)

1604 

1605  # Si no hay entradas para borrar me salgo con aviso

1606  [ "$DELETEENTRY" != "" ] || ogRaiseError log session $OG_ERR_NOTFOUND "Menuentry $LABEL" || return $?

1607 

1608  # Recorremos el fichero del final hacia el principio.

1609  ENDENTRY="$(wc -l $CFGFILE|cut -d" " -f1)"

1610  for ENTRY in $MENUENTRY; do

1611  # Comprobamos si hay que borrar la entrada.

1612  if ogCheckStringInGroup $ENTRY "$DELETEENTRY" ; then

1613  let ENDENTRY=$ENDENTRY-1

1614  sed -i -e $ENTRY,${ENDENTRY}d $CFGFILE

1615  fi

1616 

1617  # Guardamos el número de línea de la entrada, que sera el final de la siguiente.

1618  ENDENTRY=$ENTRY

1619  done

1620 }

1621 

1622 # ##

1645 

1646 function ogBurgInstallMbr ()

1647 {

1648 

1649 # Variables locales.

1650 local BINARYAVAILABLE PART DISK DEVICE MOUNTDISK FIRSTAGE SECONSTAGE PREFIXSECONDSTAGE CHECKOS KERNELPARAM BACKUPNAME FILECFG

1651 

1652 # Si se solicita, mostrar ayuda.

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

1654  ogHelp "$FUNCNAME" "$FUNCNAME int_ndiskSecondStage int_partitionSecondStage bolean_Configure_2ndStage \"param param \" " \

1655  "$FUNCNAME 1 1 FALSE " \

1656  "$FUNCNAME 1 1 TRUE \"nomodeset irqpoll pci=noacpi quiet splash \" "

1657  return

1658 fi

1659 

1660 # Error si no se reciben 2 parametros.

1661 [ $# -ge 2 ] || return $(ogRaiseError $OG_ERR_FORMAT; echo $?)

1662 

1663 #Error si no tenemos el binario burg

1664 BINARYAVAILABLE=$(burg-install -v &>/dev/null && echo "YES" ||echo "NO")

1665 if [ "$BINARYAVAILABLE" == NO ]; then

1666  if [ -e $OGLIB/burg/burg.tgz ]; then

1667  cd / ; tar xzvf $OGLIB/burg/burg.tgz --strip 1 &>/dev/null

1668  else

1669  return $(ogRaiseError $OG_ERR_NOTEXEC "Binary burg not found"; echo $?)

1670  fi

1671 fi

1672 

1673 DISK=$1; PART=$2;

1674 CHECKOS=${3:-"FALSE"}

1675 KERNELPARAM=$4

1676 BACKUPNAME=".backup.og"

1677 

1678 #Controlar disco no uefi

1679 ogIsEfiActive && return $(ogRaiseError $OG_ERR_NOTBIOS " : grub4dos solo soporta PC con bios legacy"; echo $?)

1680 #Controlar particionado tipo msdos

1681 ogCheckStringInGroup $(ogGetPartitionTableType $DISK) "MSDOS" || return $(ogRaiseError $OG_ERR_NOMSDOS ": grub2dos requiere particionado tipo MSDOS"; echo $?)

1682 #Controlar existencia de disco y particion

1683 DEVICE=$(ogDiskToDev $DISK) || ogRaiseError $OG_ERR_NOTFOUND || return $?

1684 MOUNTDISK=$(ogMount $DISK $PART) || ogRaiseError $OG_ERR_PARTITION "$MSG_ERROR " || return $?

1685 #Controlar particion segunda etapa del burg

1686 ogCheckStringInGroup $(ogGetFsType $DISK $PART) "CACHE EXT4 EXT3 EXT2" || return $(ogRaiseError $OG_ERR_PARTITION "burg.cfg soporta solo particiones linux"; echo $?)

1687 #Controlar acceso de escritura a la particion segunda etapa del burg

1688 ogIsReadonly $DISK $PART && return $(ogRaiseError $OG_ERR_NOTWRITE ": $DISK $PART" || echo $?)

1689 

1690 #Asigar la primera etapa del grub en el primer disco duro

1691 FIRSTSTAGE=$(ogDiskToDev 1)

1692 #Localizar disco segunda etapa del grub

1693 SECONDSTAGE=$(ogMount $DISK $PART)

1694 

1695 #Preparar el directorio principal de la segunda etapa (y copia los binarios)

1696 [ -d ${SECONDSTAGE}/boot/burg/ ] || mkdir -p ${SECONDSTAGE}/boot/burg/; cp -prv /boot/burg/* ${SECONDSTAGE}/boot/burg/ 2>&1>/dev/null; cp -prv $OGLIB/burg/themes ${SECONDSTAGE}/boot/burg/ 2>&1>/dev/null; #*/ ## (comentario Dogygen) #*/ ## (comentario Dogygen)

1697 #Copiar el tema de opengnsys

1698 mkdir -p ${SECONDSTAGE}/boot/burg/themes/OpenGnsys

1699 cp -prv "$OGLIB/burg/themes" "${SECONDSTAGE}/boot/burg/" 2>&1>/dev/null

1700 

1701 # No configurar la segunda etapa (grub.cfg). Parámetro FALSE

1702 if [ -f ${SECONDSTAGE}/boot/burg/burg.cfg -o -f ${SECONDSTAGE}/boot/burg/burg.cfg$BACKUPNAME ];

1703 then

1704  if [ "$CHECKOS" == "false" -o "$CHECKOS" == "FALSE" ]

1705  then

1706  burg-install --force --root-directory=${SECONDSTAGE} $FIRSTSTAGE 2>&1>/dev/null

1707  return $?

1708  fi

1709 fi

1710 

1711 # Configurrar la segunda etapa (burg.cfg) == tercer parámetro TRUE

1712 

1713 #llamar a updateBootCache para que aloje la primera fase del ogLive

1714 updateBootCache

1715 

1716 #Configur la sintaxis grub para evitar menus de "recovery" en el OGLive

1717 echo "GRUB_DISABLE_RECOVERY=\"true\"" >> /etc/default/grub

1718 echo "GRUB_DISABLE_LINUX_UUID=\"true\"" >> /etc/default/grub

1719 

1720 #Preparar configuración segunda etapa: crear ubicacion

1721 mkdir -p ${SECONDSTAGE}${PREFIXSECONDSTAGE}/boot/burg/

1722 #Preparar configuración segunda etapa: crear cabecera del fichero

1723 FILECFG=${SECONDSTAGE}${PREFIXSECONDSTAGE}/boot/burg/burg.cfg

1724 #/* ## (comentario Dogygen)

1725 cat > "$FILECFG" << EOF

1726 

1727 set theme_name=OpenGnsys

1728 set gfxmode=1024x768

1729 

1730 

1731 set locale_dir=(\$root)/boot/burg/locale

1732 

1733 set default=0

1734 set timeout=25

1735 set lang=es

1736 

1737 

1738 insmod ext2

1739 insmod gettext

1740 

1741 

1742 

1743 

1744 if [ -s \$prefix/burgenv ]; then

1745  load_env

1746 fi

1747 

1748 

1749 

1750 if [ \${prev_saved_entry} ]; then

1751  set saved_entry=\${prev_saved_entry}

1752  save_env saved_entry

1753  set prev_saved_entry=

1754  save_env prev_saved_entry

1755  set boot_once=true

1756 fi

1757 

1758 function savedefault {

1759  if [ -z \${boot_once} ]; then

1760  saved_entry=\${chosen}

1761  save_env saved_entry

1762  fi

1763 }

1764 function select_menu {

1765  if menu_popup -t template_popup theme_menu ; then

1766  free_config template_popup template_subitem menu class screen

1767  load_config \${prefix}/themes/\${theme_name}/theme \${prefix}/themes/custom/theme_\${theme_name}

1768  save_env theme_name

1769  menu_refresh

1770  fi

1771 }

1772 

1773 function toggle_fold {

1774  if test -z $theme_fold ; then

1775  set theme_fold=1

1776  else

1777  set theme_fold=

1778  fi

1779  save_env theme_fold

1780  menu_refresh

1781 }

1782 function select_resolution {

1783  if menu_popup -t template_popup resolution_menu ; then

1784  menu_reload_mode

1785  save_env gfxmode

1786  fi

1787 }

1788 

1789 

1790 if test -f \${prefix}/themes/\${theme_name}/theme ; then

1791  insmod coreui

1792  menu_region.text

1793  load_string '+theme_menu { -OpenGnsys { command="set theme_name=OpenGnsys" }}'

1794  load_config \${prefix}/themes/conf.d/10_hotkey

1795  load_config \${prefix}/themes/\${theme_name}/theme \${prefix}/themes/custom/theme_\${theme_name}

1796  insmod vbe

1797  insmod png

1798  insmod jpeg

1799  set gfxfont="Unifont Regular 16"

1800  menu_region.gfx

1801  vmenu resolution_menu

1802  controller.ext

1803 fi

1804 

1805 

1806 EOF

1807 #*/ ## (comentario Dogygen)

1808 

1809 #Preparar configuración segunda etapa: crear entrada del sistema operativo

1810 grubSyntax "$KERNELPARAM" >> "$FILECFG"

1811 #Instalar el burg

1812 burg-install --force --root-directory=${SECONDSTAGE} $FIRSTSTAGE 2>&1>/dev/null

1813 }

1814 

1815 # ##

1820 function ogGrubDefaultEntry ()

1821 {

1822  # Si se solicita, mostrar ayuda.

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

1824  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_npartition int_disk_default_entry int_npartition_default_entry" \

1825  "$FUNCNAME 1 6 1 1"

1826  return

1827  fi

1828  ogBootLoaderDefaultEntry $@

1829  return $?

1830 }

1831 

1832 # ##

1837 function ogBurgDefaultEntry ()

1838 {

1839  # Si se solicita, mostrar ayuda.

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

1841  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_npartition int_disk_default_entry int_npartition_default_entry" \

1842  "$FUNCNAME 1 6 1 1"

1843  return

1844  fi

1845  ogBootLoaderDefaultEntry $@

1846  return $?

1847 }

1848 

1849 

1850 # ##

1855 function ogRefindDefaultEntry ()

1856 {

1857  local EFIDISK EFIPART

1858  # Si se solicita, mostrar ayuda.

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

1860  ogHelp "$FUNCNAME" "$FUNCNAME int_disk_default_entry int_npartition_default_entry" \

1861  "$FUNCNAME 1 1"

1862  return

1863  fi

1864 

1865  read EFIDISK EFIPART <<< $(ogGetEsp)

1866  ogBootLoaderDefaultEntry $EFIDISK $EFIPART $@

1867  return $?

1868 }

1869 

1870 # ##

1889 function ogBootLoaderDefaultEntry ()

1890 {

1891 

1892 # Variables locales.

1893 local PART FUNC DIRMOUNT LABEL CFGFILE DEFAULTENTRY MENUENTRY MSG

1894 

1895 # Si se solicita, mostrar ayuda.

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

1897  ogHelp "$FUNCNAME" "$MSG_SEE ogGrubDefaultEntry, ogBurgDefaultEntry or ogRefindDefaultEntry."

1898  return

1899 fi

1900 

1901 # Nombre de la función que llama a esta.

1902 FUNC="${FUNCNAME[@]:1}"

1903 FUNC="${FUNC%%\ *}"

1904 

1905 # Error si no se reciben 3 parametros.

1906 [ $# -eq 4 ] || ogRaiseError $OG_ERR_FORMAT "$FUNCNAME int_ndiskSecondStage int_partitionSecondStage int_disk_default_entry int_partitions_default_entry" || return $?

1907 

1908 # Error si no puede montar sistema de archivos.

1909 DIRMOUNT=$(ogMount $1 $2) || return $?

1910 

1911 # Comprobamos que exista fichero de configuración

1912 # La función debe ser llamanda desde ogGrubDefaultEntry, ogBurgDefaultEntry or ogRefindDefaultEntry.

1913 case "$FUNC" in

1914  ogGrubDefaultEntry)

1915  CFGFILE="$DIRMOUNT/boot/grubMBR/boot/grub/grub.cfg"

1916  ;;

1917  ogBurgDefaultEntry)

1918  CFGFILE="$DIRMOUNT/boot/burg/burg.cfg"

1919  ;;

1920  ogRefindDefaultEntry)

1921  CFGFILE="$DIRMOUNT/EFI/refind/refind.conf"

1922  ;;

1923  *)

1924  ogRaiseError $OG_ERR_FORMAT "Use ogGrubDefaultEntry, ogBurgDefaultEntry or ogRefindDefaultEntry."

1925  return $?

1926  ;;

1927 esac

1928 

1929 # Error si no existe archivo de configuración

1930 [ -r $CFGFILE ] || ogRaiseError $OG_ERR_NOTFOUND "$CFGFILE" || return $?

1931 

1932 # Dispositivo

1933 if [ "$(basename $CFGFILE)" == "refind.conf" ]; then

1934  LABEL=$(printf "Part-%02d-%02d" $3 $4)

1935 else

1936  LABEL=$(ogDiskToDev $3 $4)

1937 fi

1938 

1939 # Número de línea de la entrada por defecto en CFGFILE (primera de la partición).

1940 DEFAULTENTRY=$(grep -n -m 1 menuentry.*$LABEL $CFGFILE| cut -d: -f1)

1941 

1942 # Si no hay entradas para borrar me salgo con aviso

1943 [ "$DEFAULTENTRY" != "" ] || ogRaiseError session log $OG_ERR_NOTFOUND "No menuentry $LABEL" || return $?

1944 

1945 # Número de la de linea por defecto en el menú de usuario

1946 MENUENTRY="$(grep -n -e menuentry $CFGFILE| cut -d: -f1 | grep -n $DEFAULTENTRY |cut -d: -f1)"

1947 

1948 if [ "$(basename $CFGFILE)" == "refind.conf" ]; then

1949  sed -i /default_selection.*$/d $CFGFILE

1950  sed -i "1 i\default_selection $MENUENTRY" $CFGFILE

1951 else

1952  # En grub y burg las líneas empiezan a contar desde cero

1953  let MENUENTRY=$MENUENTRY-1

1954  sed --regexp-extended -i s/"set default=\"?[0-9]*\"?$"/"set default=\"$MENUENTRY\""/g $CFGFILE

1955 fi

1956 MSG="MSG_HELP_$FUNC"

1957 echo "${!MSG%%\.}: $@"

1958 }

1959 

1960 # ##

1965 function ogGrubOgliveDefaultEntry ()

1966 {

1967  # Si se solicita, mostrar ayuda.

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

1969  ogHelp "$FUNCNAME" "$FUNCNAME int_ndiskSecondStage int_partitionSecondStage" \

1970  "$FUNCNAME 1 6"

1971  return

1972  fi

1973  ogBootLoaderOgliveDefaultEntry $@

1974  return $?

1975 }

1976 

1977 # ##

1982 function ogBurgOgliveDefaultEntry ()

1983 {

1984  # Si se solicita, mostrar ayuda.

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

1986  ogHelp "$FUNCNAME" "$FUNCNAME int_ndiskSecondStage int_partitionSecondStage" \

1987  "$FUNCNAME 1 6"

1988  return

1989  fi

1990  ogBootLoaderOgliveDefaultEntry $@

1991  return $?

1992 }

1993 

1994 

1995 # ##

2000 function ogRefindOgliveDefaultEntry ()

2001 {

2002  local EFIDISK EFIPART

2003  # Si se solicita, mostrar ayuda.

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

2005  ogHelp "$FUNCNAME" "$FUNCNAME" \

2006  "$FUNCNAME"

2007  return

2008  fi

2009 

2010  read EFIDISK EFIPART <<< $(ogGetEsp)

2011  ogBootLoaderOgliveDefaultEntry $EFIDISK $EFIPART

2012  return $?

2013 }

2014 

2015 

2016 # ##

2033 function ogBootLoaderOgliveDefaultEntry ()

2034 {

2035 

2036 # Variables locales.

2037 local FUNC PART CFGFILE NUMENTRY MSG

2038 

2039 # Si se solicita, mostrar ayuda.

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

2041  ogHelp "$FUNCNAME" "$MSG_SEE ogGrubOgliveDefaultEntry, ogBurgOgliveDefaultEntry or ogRefindOgliveDefaultEntry" \

2042  return

2043 fi

2044 

2045 # Nombre de la función que llama a esta.

2046 FUNC="${FUNCNAME[@]:1}"

2047 FUNC="${FUNC%%\ *}"

2048 

2049 # Error si no se reciben 2 parametros.

2050 [ $# -eq 2 ] || ogRaiseError $OG_ERR_FORMAT "$FUNCNAME int_ndiskSecondStage int_partitionSecondStage" || return $?

2051 

2052 # Error si no puede montar sistema de archivos.

2053 PART=$(ogMount $1 $2) || return $?

2054 # La función debe ser llamanda desde ogGrubOgliveDefaultEntry, ogBurgOgliveDefaultEntry or ogRefindOgliveDefaultEntry.

2055 case "$FUNC" in

2056  ogGrubOgliveDefaultEntry)

2057  CFGFILE="$PART/boot/grubMBR/boot/grub/grub.cfg"

2058  ;;

2059  ogBurgOgliveDefaultEntry)

2060  CFGFILE="$PART/boot/burg/burg.cfg"

2061  ;;

2062  ogRefindOgliveDefaultEntry)

2063  CFGFILE="$PART/EFI/refind/refind.conf"

2064  ;;

2065  *)

2066  ogRaiseError $OG_ERR_FORMAT "Use ogGrubOgliveDefaultEntry, ogBurgOgliveDefaultEntry or ogRefindOgliveDefaultEntry."

2067  return $?

2068  ;;

2069 esac

2070 

2071 # Comprobamos que exista fichero de configuración

2072 [ -f $CFGFILE ] || ogRaiseError $OG_ERR_NOTFOUND "$CFGFILE" || return $?

2073 

2074 # Detectamos cual es la entrada de ogLive

2075 NUMENTRY=$(grep ^menuentry $CFGFILE| grep -n "OpenGnsys Live"|cut -d: -f1)

2076 

2077 # Si no existe entrada de ogLive nos salimos

2078 [ -z "$NUMENTRY" ] && (ogRaiseError $OG_ERR_NOTFOUND "menuentry OpenGnsys Live in $CFGFILE" || return $?)

2079 

2080 if [ "$(basename $CFGFILE)" == "refind.conf" ]; then

2081  sed -i /default_selection.*$/d $CFGFILE

2082 

2083  sed -i "1 i\default_selection $NUMENTRY" $CFGFILE

2084 else

2085  let NUMENTRY=$NUMENTRY-1

2086  sed --regexp-extended -i s/"set default=\"?[0-9]+\"?"/"set default=\"$NUMENTRY\""/g $CFGFILE

2087 fi

2088 

2089 MSG="MSG_HELP_$FUNC"

2090 echo "${!MSG%%\.}: $@"

2091 }

2092 

2093 

2094 # ##

2108 function ogGrubSecurity ()

2109 {

2110 # Variables locales.

2111 local SECONDSTAGE GRUBGFC FILE USER PASSWD ENCRYPTPASSWD

2112 

2113 # Si se solicita, mostrar ayuda.

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

2115  ogHelp "$FUNCNAME" "$FUNCNAME int_ndiskSecondStage int_partitionSecondStage [USER] [PASSWORD]" \

2116  "$FUNCNAME 1 1 " \

2117  "$FUNCNAME 1 2 user clave"

2118  return

2119 fi

2120 

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

2122 [ $# -ge 2 ] || ogRaiseError $OG_ERR_FORMAT "$FUNCNAME int_ndiskSecondStage int_partitionSecondStage [USER] [PASSWORD]"|| return $?

2123 

2124 #localizar disco segunda etapa del grub

2125 SECONDSTAGE=$(ogMount "$1" "$2") || return $?

2126 

2127 GRUBGFC=$(ls $SECONDSTAGE/{,boot/}{{grubMBR,grubPARTITION}/boot/,}{grub{,2},{,efi/}EFI/*}/{menu.lst,grub.cfg,grub.cfg.backup.og} 2>/dev/null)

2128 

2129 # comprobamos que exista el archivo de configuración.

2130 [ -n "$GRUBGFC" ] || ogRaiseError $OG_ERR_NOTFOUND "grub.cfg" || return $?

2131 

2132 USER=${3:-root}

2133 PASSWD=${4:-""}

2134 

2135 ENCRYPTPASSWD=$(echo -e "$PASSWD\n$PASSWD"|grub-mkpasswd-pbkdf2|sed -e 1,2d -e s/^.*grub/grub/)

2136 

2137 for FILE in $GRUBGFC; do

2138  # Eliminamos configuración anterior

2139  sed -i -e /superusers/d -e /password_pbkdf2/d $FILE

2140 

2141  # Configuramos grub.cfg para que sólo permita editar o entrar en línea de comandos al usuario especificado

2142  [ "$PASSWD" == "" ] || sed -i "1i\password_pbkdf2 $USER $ENCRYPTPASSWD" $FILE

2143  sed -i "1i\set superusers=\"$USER\"" $FILE

2144 

2145  # Permitimos que se seleccionen las entradas

2146  sed -i /"menuentry "/s/"{"/"--unrestricted {"/ $FILE

2147 done

2148 }

2149 

2150 

2151 # ##

2156 function ogGrubSetTheme ()

2157 {

2158  # Si se solicita, mostrar ayuda.

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

2160  ogHelp "$FUNCNAME" "$FUNCNAME int_ndiskSecondStage int_partitionSecondStage str_themeName" \

2161  "$FUNCNAME 1 4 ThemeBasic"\

2162  "$FUNCNAME \$(ogFindCache) ThemeBasic"

2163  return

2164  fi

2165  ogBootLoaderSetTheme $@

2166  return $?

2167 }

2168 

2169 # ##

2174 function ogBurgSetTheme ()

2175 {

2176  # Si se solicita, mostrar ayuda.

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

2178  ogHelp "$FUNCNAME" "$FUNCNAME int_ndiskSecondStage int_partitionSecondStage str_themeName" \

2179  "$FUNCNAME 1 4 ThemeBasic" \

2180  "$FUNCNAME \$(ogFindCache) ThemeBasic"

2181  echo "Temas disponibles:\ $(ls $OGCAC/boot/burg/themes/)"

2182 

2183  return

2184  fi

2185  ogBootLoaderSetTheme $@

2186  return $?

2187 }

2188 

2189 

2190 # ##

2195 function ogRefindSetTheme () {

2196  local PART DIRTHEME CFGFILE

2197  # Si se solicita, mostrar ayuda.

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

2199  ogHelp "$FUNCNAME" "$FUNCNAME str_themeName" \

2200  "$FUNCNAME ThemeBasic"

2201  echo -e "\nThemes in $OGLIB/refind:\n$(ls $OGLIB/refind/themes/ 2>/dev/null)"

2202 

2203  return

2204  fi

2205 

2206  # Detectamos partición ESP

2207  read EFIDISK EFIPART <<< $(ogGetEsp)

2208 

2209  PART=$(ogMount $EFIDISK $EFIPART) || return $?

2210  DIRTHEME="$PART/EFI/refind/themes"

2211  CFGFILE="$PART/EFI/refind/refind.conf"

2212 

2213  # Para utilizar ogBootLoaderSetTheme es necesario la entrada set theme_name

2214  if [ -f $CFGFILE ]; then

2215  sed -i '1 i\set theme_name=none' $CFGFILE

2216  else

2217  ogRaiseError $OG_ERR_NOTFOUND "$CFGFILE" || return $?

2218  fi

2219  # Creamos el directorio para los temas

2220  [ -d $DIRTHEME ] || mkdir $DIRTHEME

2221 

2222  ogBootLoaderSetTheme $EFIDISK $EFIPART $@

2223  return $?

2224 }

2225 

2226 

2227 # ##

2247 function ogBootLoaderSetTheme ()

2248 {

2249 

2250 # Variables locales.

2251 local FUNC PART CFGFILE THEME NEWTHEME BOOTLOADER MSG NEWTHEMECFG

2252 

2253 # Si se solicita, mostrar ayuda.

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

2255  ogHelp "$FUNCNAME" "$MSG_SEE ogGrubSetTheme, ogBurgSetTheme or ogRefindSetTheme."

2256  return

2257 fi

2258 

2259 

2260 NEWTHEME="$3"

2261 

2262 # Nombre de la función que llama a esta.

2263 FUNC="${FUNCNAME[@]:1}"

2264 FUNC="${FUNC%%\ *}"

2265 

2266 

2267 

2268 # Error si no se reciben 3 parametros.

2269 [ $# -eq 3 ] || ogRaiseError $OG_ERR_FORMAT "$FUNCNAME int_ndiskSecondStage int_partitionSecondStage str_themeName" || return $?

2270 

2271 # Error si no puede montar sistema de archivos.

2272 PART=$(ogMount $1 $2) || return $?

2273 # La función debe ser llamanda desde ogGrubSetTheme, ogBurgSetTheme or ogRefindSetTheme.

2274 case "$FUNC" in

2275  ogGrubSetTheme)

2276  BOOTLOADER="grub"

2277  BOOTLOADERDIR="boot/grubMBR"

2278  CFGFILE="$PART/boot/grubMBR/boot/grub/grub.cfg"

2279  ogRaiseError $OG_ERR_FORMAT "ogGrubSetTheme not sopported"

2280  return $?

2281  ;;

2282  ogBurgSetTheme)

2283  BOOTLOADER="burg"

2284  BOOTLOADERDIR="boot/burg"

2285  CFGFILE="$PART/boot/burg/burg.cfg"

2286  ;;

2287  ogRefindSetTheme)

2288  BOOTLOADER="refind"

2289  BOOTLOADERDIR="EFI/refind"

2290  CFGFILE="$PART/EFI/refind/refind.conf"

2291  ;;

2292  *)

2293  ogRaiseError $OG_ERR_FORMAT "Use ogGrubSetTheme, ogBurgSetTheme or ogRefindSetTheme."

2294  return $?

2295  ;;

2296 esac

2297 

2298 # Comprobamos que exista fichero de configuración

2299 [ -f $CFGFILE ] || ogRaiseError $OG_ERR_NOTFOUND "$CFGFILE" || return $?

2300 

2301 # Detectamos cual es el tema asignado

2302 THEME=$(grep "set theme_name=" $CFGFILE | grep ^set | cut -d= -f2)

2303 # Si no existe entrada de theme_name nos salimos

2304 [ -z "$THEME" ] && (ogRaiseError $OG_ERR_NOTFOUND "theme_name in $CFGFILE" || return $?)

2305 

2306 #Actualizamos el tema del servidor a la particion

2307 if [ -d $OGLIB/$BOOTLOADER/themes/$NEWTHEME ]; then

2308  # Para refind es necesario que exista theme.conf en el directorio del tema.

2309  if [ "$BOOTLOADER" == "refind" ]; then

2310  NEWTHEMECFG="$OGLIB/$BOOTLOADER/themes/$NEWTHEME/theme.conf"

2311  [ -f $NEWTHEMECFG ] || ogRaiserError $OG_ERR_NOTFOUND "theme.conf" || return $?

2312  grep -v "^#" $NEWTHEMECFG >> $CFGFILE

2313  # eliminamos "set theme" es de grub y no de refind

2314  sed -i '/theme_name/d' $CFGFILE

2315  fi

2316  cp -pr $OGLIB/$BOOTLOADER/themes/$NEWTHEME $PART/$BOOTLOADERDIR/themes/

2317 fi

2318 

2319 #Verificamos que el tema esta en la particion

2320 if ! [ -d $PART/$BOOTLOADERDIR/themes/$NEWTHEME ]; then

2321  ogRaiseError $OG_ERR_NOTFOUND "theme_name=$NEWTHEME in $PART/$BOOTLOADERDIR/themes/" || return $?

2322 fi

2323 

2324 #Cambiamos la entrada el fichero de configuración.

2325 sed --regexp-extended -i s/"set theme_name=$THEME"/"set theme_name=$NEWTHEME"/g $CFGFILE

2326 

2327 

2328 }

2329 

2330 # ##

2335 function ogGrubSetAdminKeys ()

2336 {

2337  # Si se solicita, mostrar ayuda.

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

2339  ogHelp "$FUNCNAME" "$FUNCNAME int_ndiskSecondStage int_partitionSecondStage str_bolean" \

2340  "$FUNCNAME 1 4 FALSE "\

2341  "$FUNCNAME \$(ogFindCache) ThemeBasic"

2342  return

2343  fi

2344  ogBootLoaderSetAdminKeys $@

2345  return $?

2346 }

2347 

2348 # ##

2353 function ogBurgSetAdminKeys ()

2354 {

2355  # Si se solicita, mostrar ayuda.

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

2357  ogHelp "$FUNCNAME" "$FUNCNAME int_ndiskSecondStage int_partitionSecondStage str_bolean" \

2358  "$FUNCNAME 1 4 TRUE" \

2359  "$FUNCNAME \$(ogFindCache) FALSE"

2360  return

2361  fi

2362  ogBootLoaderSetAdminKeys $@

2363  return $?

2364 }

2365 

2366 

2367 

2368 # ##

2383 function ogBootLoaderSetAdminKeys ()

2384 {

2385 

2386 # Variables locales.

2387 local FUNC PART CFGFILE BOOTLOADER BOOTLOADERDIR CFGFILE MSG

2388 

2389 # Si se solicita, mostrar ayuda.

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

2391  ogHelp "$FUNCNAME" "$MSG_SEE ogGrubSetSetAdminKeys ogBurgSetSetAdminKeys"

2392  return

2393 fi

2394 

2395 

2396 # Nombre de la función que llama a esta.

2397 FUNC="${FUNCNAME[@]:1}"

2398 FUNC="${FUNC%%\ *}"

2399 

2400 

2401 # Error si no se reciben 2 parametros.

2402 [ $# -eq 3 ] || ogRaiseError $OG_ERR_FORMAT "$FUNCNAME int_ndiskSecondStage int_partitionSecondStage str_bolean" || return $?

2403 

2404 # Error si no puede montar sistema de archivos.

2405 PART=$(ogMount $1 $2) || return $?

2406 # La función debe ser llamanda desde ogGrubSetAdminKeys or ogBurgSetAdminKeys.

2407 case "$FUNC" in

2408  ogGrubSetAdminKeys)

2409  BOOTLOADER="grub"

2410  BOOTLOADERDIR="grubMBR"

2411  CFGFILE="$PART/boot/grubMBR/boot/grub/grub.cfg"

2412  ogRaiseError $OG_ERR_FORMAT "ogGrubSetAdminKeys not sopported"

2413  return $?

2414  ;;

2415  ogBurgSetAdminKeys)

2416  BOOTLOADER="burg"

2417  BOOTLOADERDIR="burg"

2418  CFGFILE="$PART/boot/burg/burg.cfg"

2419  ;;

2420  *)

2421  ogRaiseError $OG_ERR_FORMAT "Use ogGrubSetAdminKeys"

2422  return $?

2423  ;;

2424 esac

2425 

2426 

2427 # Comprobamos que exista fichero de configuración

2428 [ -f $CFGFILE ] || ogRaiseError $OG_ERR_NOTFOUND "$CFGFILE" || return $?

2429 

2430 

2431 case "$3" in

2432  true|TRUE)

2433  [ -f ${OGCAC}/boot/$BOOTLOADERDIR/themes/conf.d/10_hotkey.disabled ] && mv ${OGCAC}/boot/$BOOTLOADERDIR/themes/conf.d/10_hotkey.disabled ${OGCAC}/boot/$BOOTLOADERDIR/themes/conf.d/10_hotkey

2434  ;;

2435  false|FALSE)

2436  [ -f ${OGCAC}/boot/$BOOTLOADERDIR/themes/conf.d/10_hotkey ] && mv ${OGCAC}/boot/$BOOTLOADERDIR/themes/conf.d/10_hotkey ${OGCAC}/boot/$BOOTLOADERDIR/themes/conf.d/10_hotkey.disabled

2437  ;;

2438  *)

2439  ogRaiseError $OG_ERR_FORMAT "str bolean unknow "

2440  return $?

2441  ;;

2442 esac

2443 }

2444 

2445 

2446 

2447 # ##

2452 function ogGrubSetTimeOut ()

2453 {

2454  # Si se solicita, mostrar ayuda.

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

2456  ogHelp "$FUNCNAME" "$FUNCNAME int_ndiskSecondStage int_partitionSecondStage int_timeout_seconds" \

2457  "$FUNCNAME 1 4 50 "\

2458  "$FUNCNAME \$(ogFindCache) 50"

2459  return

2460  fi

2461  ogBootLoaderSetTimeOut $@

2462  return $?

2463 }

2464 

2465 # ##

2470 function ogBurgSetTimeOut ()

2471 {

2472  # Si se solicita, mostrar ayuda.

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

2474  ogHelp "$FUNCNAME" "$FUNCNAME int_ndiskSecondStage int_partitionSecondStage str_timeout_seconds" \

2475  "$FUNCNAME 1 4 50" \

2476  "$FUNCNAME \$(ogFindCache) 50"

2477  return

2478  fi

2479  ogBootLoaderSetTimeOut $@

2480  return $?

2481 }

2482 

2483 

2484 # ##

2489 function ogRefindSetTimeOut ()

2490 {

2491  local EFIDISK EFIPART

2492  # Si se solicita, mostrar ayuda.

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

2494  ogHelp "$FUNCNAME" "$FUNCNAME int_timeout_seconds" \

2495  "$FUNCNAME 50"

2496  return

2497  fi

2498 

2499  read EFIDISK EFIPART <<< $(ogGetEsp)

2500  ogBootLoaderSetTimeOut $EFIDISK $EFIPART $@

2501  return $?

2502 }

2503 

2504 # ##

2519 function ogBootLoaderSetTimeOut ()

2520 {

2521 

2522 # Variables locales.

2523 local FUNC PART CFGFILE TIMEOUT BOOTLOADER BOOTLOADERDIR CFGFILE MSG

2524 

2525 # Si se solicita, mostrar ayuda.

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

2527  ogHelp "$FUNCNAME" "$MSG_SEE ogGrubSetTimeOut, ogBurgSetTimeOut or ogRefindSetTimeOut"

2528  return

2529 fi

2530 

2531 ogCheckStringInReg $3 "^[0-9]{1,10}$" && TIMEOUT="$3" || ogRaiseError $OG_ERR_FORMAT "param 3 is not a integer"

2532 

2533 # Nombre de la función que llama a esta.

2534 FUNC="${FUNCNAME[@]:1}"

2535 FUNC="${FUNC%%\ *}"

2536 

2537 # Error si no se reciben 3 parametros.

2538 [ $# -eq 3 ] || ogRaiseError $OG_ERR_FORMAT "$FUNCNAME int_ndiskSecondStage int_partitionSecondStage int_timeout_seconds" || return $?

2539 

2540 # Error si no puede montar sistema de archivos.

2541 PART=$(ogMount $1 $2) || return $?

2542 # La función debe ser llamanda desde ogGrubSetTimeOut, ogBurgSetTimeOut or ogRefindSetTimeOut.

2543 case "$FUNC" in

2544  ogGrubSetTimeOut)

2545  BOOTLOADER="grub"

2546  BOOTLOADERDIR="boot/grubMBR"

2547  CFGFILE="$PART/boot/grubMBR/boot/grub/grub.cfg"

2548  ;;

2549  ogBurgSetTimeOut)

2550  BOOTLOADER="burg"

2551  BOOTLOADERDIR="boot/burg"

2552  CFGFILE="$PART/boot/burg/burg.cfg"

2553  ;;

2554  ogRefindSetTimeOut)

2555  BOOTLOADER="refind"

2556  BOOTLOADERDIR="EFI/refind"

2557  CFGFILE="$PART/EFI/refind/refind.conf"

2558  ;;

2559  *)

2560  ogRaiseError $OG_ERR_FORMAT "Use ogGrubSetTimeOut, ogBurgSetTimeOut or ogRefindSetTimeOut."

2561  return $?

2562  ;;

2563 esac