Avviare al boot un programma con wine che necessita di finestre

Per avviare un software studiato per windows sul proprio server Ubuntu si deve dapprima avere installato wine con il comando

sudo apt-get install wine

se possibile installare l'ultima versione aggiungendo un file col nome ppawine.list (o altro nome la cosa importante è che il file termini con .list) dentro /etc/apt/sources.list.d/ e dentro ci scrivi gli indirizzi del repository cercandoli alla pagina https://launchpad.net/~ubuntu-wine/+archive/ppa (ad oggi NDR l'ultima versione è la 1.4) per la propria distribuzione es.

deb http://ppa.launchpad.net/ubuntu-wine/ppa/ubuntu lucid main
deb-src http://ppa.launchpad.net/ubuntu-wine/ppa/ubuntu lucid main

se dovesse venir richiesta una chiave si deve aggiungerla con il comando

sudo apt-key adv --recv-keys --keyserver keyserver.ubuntu.com CHIAVE

dove CHIAVE è il numero della chiave pubblica che compare nell'errore dopo aver fatto

sudo apt-get update

lanciare il programma all' avvio con una delle 2 modalità dapprima si crea un file .sh dove verranno inseriti i comandi che ci servono per far partire l'applicazione poi si deve dargli i permessi di esecuzione tramite il comando

sudo chmod a+x nomefile.sh

ed ecco le due strade

1. Se il programma non ha "urgenza" di essere avviato o per meglio dire non ha priorità specifiche è sufficiente aggiungereal file /etc/rc.local il lancio del nostro file
2. copiare il file in /etc/init.d/ e succesivamente lanciare

sudo update-rc.d nomescript.sh defaults
per eliminare
sudo update-rc.d nomescript.sh remove

esempio file .sh

/usr/bin/wine /var/provaserver/programma.exe 2>/home/utente/log_provaserver.log
il 2> serve per avere in un file gli eventuali errori

il problema nasce dal fatto che wine o meglio il software che avviamo da wine deve aprire una finestra sul display e quindi lanciandolo dal boot si otterrà questo errore nel file di log

Application tried to create a window, but no driver could be loaded.
Make sure that your X server is running and that $DISPLAY is set correctly.
err:systray:initialize_systray Could not create tray window

per ovviare a questo problema ci viene in aiuto xvfb che tramite il comando xvfb-run avvia ad un server X virtuale il comando, dobbiamo quindi modificare il nostro fle sh nel seguente modo

xvfb-run/usr/bin/wine /var/provaserver/programma.exe 2> /home/utente/log_provaserver.log

risolvendo il problema e facendo funzionare il nostro programma. 

Se come nel nostro caso il computer dovesse non proseguire con il boot a causa del programma che abbiamo avviato dovremmo inserire la & dopo il comando ma prima di 2> e per sicurezza utilizziamo anche nohup che ci permette di avviarlo senza creare un terminale riducendo le possibilità di terminare involotariamente l'esecuzione del programma:

nohup xvfb-run/usr/bin/wine /var/provaserver/programma.exe & 2> /home/utente/log_provaserver.log

Installazione pacchetto ted per la conversione di rtf in pdf

Ted è una Gui per la visualizzazione e la modifica di file Rtf che grazie a degli script permette di convertire tali Rtf in Pdf , Html ecc..

Le dipendenze di questo pacchetto sono:

• lesstif2
• libc6 (>= 2.7-1)
• libice6 (>= 1:1.0.0)
• libjpeg62
• libpng12-0 (>= 1.2.13-4)
• libsm6
• libtiff4
• libx11-6
• libxext6
• libxpm4
• libxt6
• ted-common (= 2.17-1ubuntu1)
• zlib1g (>= 1:1.2.3.3.dfsg-1)

Per installare il pacchetto ted si deve inanzitutto installare la libreria lesstif2 ( le altre dipenze solitamente sono già soddisfatte

sudo aptitude install lesstif2

 scaricare i pacchetti .deb da launchpad

• prima di tutto il file ted-common ( al momento siamo alla versione 2.17)
  
  wget http://launchpadlibrarian.net/11313542/ted-common_2.17-1ubuntu1_all.deb
  
  sudo dpkg -i ted-common_2.17-1ubuntu1_all.deb
  
• nel mio caso devo installare il pacchetto per processore 64bit
  wget https://launchpad.net/ubuntu/+source/ted/2.17-1ubuntu1/+build/489695/+files/ted_2.17-1ubuntu1_amd64.deb
  
  sudo dpkg -i ted_2.17-1ubuntu1_amd64.deb
  
• Con i seguenti script è possibile convertire tramite shell i documenti rtf in vari formati.

1. rtf2pdf.sh

   #!/bin/sh
   
   ########################################################################
   #
   #  Convert an rtf document to pdf format using 'Ted' and 'GhostScript'.
   #
   #  Usage rtf2pdf.sh --paper paper something.rtf something.pdf
   #  Or  rtf2pdf.sh something.rtf something.pdf
   #
   #  Valid values for paper are a4, a5, a6, letter, legal and executive
   #
   #  This is an example. Refer to http://www.nllgg.nl/Ted/index.html for the
   #  'Ted' documentation.
   #
   #  If you want 'Ted' to set configurable resources, use
   #  Ted  --printToFilePaper --setProperty ... in the Ted way. E.G:
   #  Ted  --setProperty usePostScriptFilters 1 \
   # --setProperty usePostScriptIndexedImages 1  \
   # --setProperty afmDirectory /usr/share/ghostscript/fonts  \
   # --setProperty fontDirectory /usr/share/ghostscript/fonts  \
   # --setProperty ghostscriptFontmap \
   #    /usr/share/ghostscript/6.53/lib/Fontmap \
   # --setProperty ghostscriptFontToXmapping \
   #    /usr/share/ghostscript/6.53/lib/fonts.dir \
   # --printToFilePaper .....
   #  This has the advantage over the ++printToFilePaper call and X11 
   #  resource settings with -xrm Ted.usePostScriptFilters:1 style arguments 
   #  that it does not require an X11 server.
   #  The settings can also be stored in /etc/Ted.properties or in 
   #  $(HOME)/.Ted.properies files. Refer to the Ted documentation for 
   #  more details.
   #
   #  The file /usr/share/ghostscript/version/doc/Ps2pdf.htm documents 
   #  many settings for ghostscript that influence the generation of pdf.
   #  The actual meaning of the parameters is explained in Adobe technical 
   #  note #5151: "Acobat Distiller Parameters". With some effort, note #5151 
   #  can be found using the search facility on www.adobe.com.
   #
   #  To disable jpeg compression of 8 bit per component images:
   #      -dAutoFilterColorImages=false -dEncodeColorImages=false
   #  or
   #      -dAutoFilterColorImages=false -sColorImageFilter=FlateEncode
   #  to enable: (default)
   #      -dAutoFilterColorImages=true
   #
   #  To produce uncompressed pdf:
   #      -dCompressPages=false
   #  To produce compressed pdf: (default)
   #      -dCompressPages=true
   #
   #  Depending on your temper, you could also have a look at the pdfopt script
   #
   ########################################################################
   
   PAPER=
   PARAMS="--setProperty usePostScriptFilters 1 --setProperty usePostScriptIndexedImages 1"
   
   ps=/tmp/$$.ps
   trap "rm -f ${ps}" 0
   
   case $# in
       1|2)
    ;;
       3|4)
    case $1 in
        --paper)
     ;;
        *)
     echo $0: '$1='$1 'Expected --paper'
     exit 1
     ;;
    esac
   
    case $2 in
        a4|a5|a6|letter|legal|executive)
     PAPER=$2
     ;;
        *)
     echo $0: '$2='$2 'Expected a4|a5|a6|letter|legal|executive'
     exit 1
     ;;
    esac
    shift; shift;
    ;;
       *)
    echo $0: '$#='$#
    exit 1
    ;;
   esac
   
   case $# in
       1)
    rtf="$1";
    pdf=`basename "$1" .rtf`.pdf
    ;;
       2)
    rtf="$1";
    pdf="$2";
    ;;
       *)
    echo $0: '$#='$#
    exit 1
    ;;
   esac
   
   case $PAPER in
       ?*)
    Ted ${PARAMS} --printToFilePaper "$rtf" "$ps" $PAPER
   
    gs -q -dNOPAUSE    \
     -sDEVICE=pdfwrite   \
     -sPAPERSIZE=$PAPER   \
     -sOutputFile="$pdf"   \
     "$ps"     \
     -c quit
    ;;
       *)
    Ted ${PARAMS} --printToFile "$rtf" "$ps"
   
    gs -q -dNOPAUSE    \
     -sDEVICE=pdfwrite   \
     -sOutputFile="$pdf"   \
     "$ps"     \
     -c quit
    ;;
   esac

2. rtf2ps.sh
   

   #!/bin/sh
   
   ########################################################################
   #
   #  Convert an rtf document to PostScript format using 'Ted'.
   #
   #  Usage rtf2ps.sh --paper paper something.rtf something.ps
   #  Or  rtf2ps.sh something.rtf something.ps
   #
   #  Valid values for paper are a4, a5, a6, letter, legal and executive
   #
   #  This is an example. Refer to http://www.nllgg.nl/Ted/index.html for the
   #  'Ted' documentation.
   #
   #  If you want 'Ted' to set configurable resources, use
   #  Ted  --printToFilePaper --setProperty ... in the Ted way. E.G:
   #  Ted  --setProperty usePostScriptFilters 1 \
   # --setProperty usePostScriptIndexedImages 1  \
   # --setProperty afmDirectory /usr/share/ghostscript/fonts  \
   # --setProperty fontDirectory /usr/share/ghostscript/fonts  \
   # --setProperty ghostscriptFontmap \
   #    /usr/share/ghostscript/6.53/lib/Fontmap \
   # --setProperty ghostscriptFontToXmapping \
   #    /usr/share/ghostscript/6.53/lib/fonts.dir \
   # --printToFilePaper .....
   #  This has the advantage over the ++printToFilePaper call and X11 
   #  resource settings with -xrm Ted.usePostScriptFilters:1 style arguments 
   #  that it does not require an X11 server.
   #  The settings can also be stored in /etc/Ted.properties or in 
   #  $(HOME)/.Ted.properies files. Refer to the Ted documentation for 
   #  more details.
   #
   ########################################################################
   
   PAPER=
   
   case $# in
       1|2)
    ;;
       3|4)
    case $1 in
        --paper)
     ;;
        *)
     echo $0: '$1='$1 'Expected --paper'
     exit 1
     ;;
    esac
   
    case $2 in
        a4|a5|a6|letter|legal|executive)
     PAPER=$2
     ;;
        *)
     echo $0: '$2='$2 'Expected a4|a5|a6|letter|legal|executive'
     exit 1
     ;;
    esac
    shift; shift;
    ;;
       *)
    echo $0: '$#='$#
    exit 1
    ;;
   esac
   
   case $# in
       1)
    rtf="$1";
    ps=`basename "$1" .rtf`.ps
    ;;
       2)
    rtf="$1";
    ps="$2";
    ;;
       *)
    echo $0: '$#='$#
    exit 1
    ;;
   esac
   
   case $PAPER in
       ?*)
    Ted --printToFilePaper "$rtf" "$ps" $PAPER
    ;;
       *)
    Ted --printToFile "$rtf" "$ps"
    ;;
   esac
   

3. rtf2txt
   

   #!/bin/sh
   
   ########################################################################
   #
   #  Convert an rtf document to plain text format using 'Ted'.
   #
   #  Usage rtf2txt.sh something.rtf something.txt
   #
   #  This is an example. Refer to http://www.nllgg.nl/Ted/index.html for the
   #  'Ted' documentation.
   #
   ########################################################################
   
   case $# in
       1)
    rtf="$1";
    txt=`basename "$1" .rtf`.txt
    ;;
       2)
    rtf="$1";
    txt="$2";
    ;;
       *)
    echo $0: '$#='$#
    exit 1
    ;;
   esac
   
   Ted --saveTo "$rtf" "$txt"

4. rtftohtml
   

   #!/bin/sh
   
   ########################################################################
   #
   #  Convert an rtf document to plain text format using 'Ted'.
   #
   #  Usage rtf2txt.sh something.rtf something.txt
   #
   #  This is an example. Refer to http://www.nllgg.nl/Ted/index.html for the
   #  'Ted' documentation.
   #
   ########################################################################
   
   case $# in
       1)
    rtf="$1";
    txt=`basename "$1" .rtf`.html
    ;;
       2)
    rtf="$1";
    html="$2";
    ;;
       *)
    echo $0: '$#='$#
    exit 1
    ;;
   esac
   
   Ted ++saveTo "$rtf" "$html"

5. 
   
   

Creare .deb da un .tar.gz con checkinstall

Checkinstall è una utilità molto utile per creare pacchetti .deb per Debian o Ubuntu da file .tar.gz (o .tgz) di sorgenti dopo averli compilati nella tua distribuzione.
Praticamente si prepara il pacchetto per un successivo utilizzo senza il bisogno di compilare il tutto sulla tua macchina linux.
Un'altra applicazione di checkinstall è la disinstallazione del pacchetto dopo averlo installato dai sorgenti.
Come avrete notato non tutti i programmi aggiungono la regola "uninstall" al Makefile e quindi il comando "make uninstall" non andrebbe a buon fine.
La soluzione migliore è utilizzare checkinstall pre preparare i pacchetti dai sorgenti e installarli e disinstallarli con dpkg.
Questa procedura spiga come preparare il .deb di clamav dai sorgenti

1. installare checkinstall
sudo aptitude -y install checkinstall (Ubuntu, Debian e derivate)
2. Reperire i sorgenti da installare
   wget http://mesh.dl.sourceforge.net/sourceforge/clamav/clamav-0.81.tar.gz (per esempio)
3. Installare le dipendenze e le librerie che servono per il funzionamento del pacchetto
   sudo aptitude install libgmp3 libgmp3-dev
4. Compilare i sorgenti
   tar xvfz clamav-0.81.tar.gz
cd clamav-0.81/
./configure --sysconfdir=/etc
make
5. Esegui checkinstall e segui le istruzioni (descrizione pacchetto ecc..):
   sudo checkinstall -D make install
6. Quando sarà finito avremo clamav-0.81_0.81-1_i386.deb e si potrà installarlo con sudo dpkg -i clamav-0.81_0.81-1_i386.deb oppure copiarlo su un'altro computer per un'altra installazione.

Come autenticarsi in Linux senza password con le chiavi SSH

SSH è un fantastico strumento per gli amministratori di sistema. Consente di eseguire comandi da remoto, copiare file in rete, creare dei tunnel e tutto sfruttando i più robusti algoritmi di cifratura. Inoltre consente di stabilire delle rigide politiche riguardo l'autenticazione, come gli host o i PC da autenticare, utenti, ecc.
Quello di cui vi vorremmo parlare oggi è la possibilità di OpenSSH di autenticare un utente in base a uno scambio di chiavi, senza che venga richiesta la password e senza che questo possa rendere meno sicuro il nostro sistema. Di solito infatti siamo abituati a inserire una password per accedere a un sistema. Il concetto è quello di inserire una chiave pubblica (possedendo solo noi la corrispondente chiave privata) all'interno della configurazione di SSH sull'host remoto sul quale vorremmo autenticarci. In questo modo al tentativo di connessione SSH controllerà se la nostra chiave privata e la chiave pubblica lì presente fanno parte della stessa coppia e, in caso positivo, ci darà accesso al sistema.
Trovare una chiave privata a partire da una pubblica è infatti praticamente impossibile, e certamente più difficile di trovare una password. Se la mancanza di richiesta di password vi sconvolge pensate che comunque per assegnarla al server sarà necessario il login: non è quindi un'operazione che possono svolgere tutti, ma solo coloro che hanno già le giuste credenziali di accesso.
In pratica genereremo una coppia di chiavi, una pubblica e una privata. Quella pubblica verrà copiata sul server. Quando il server ci chiederà chi siamo, il nostro client genererà una firma a partire dalla nostra chiave pubblica. Il server, in possesso della chiave pubblica, può controllare se quella firma è stata generata da una chiave privata corrispondente alla chiave pubblica in suo possesso. In caso positivo verrà dato accesso al sistema.
Generiamo quindi la coppia di chiavi con il comando ssh-keygen, ci verrà chiesto di inserire un percorso (va bene anche quello proposto di default) e una passphrase (che sarà bene inserire e non usare una vuota a me no che non si voglia utilizzare degli automatismi in tale caso è opportuna lasciarla vuota) per la generazione delle chiavi:

[utente@linuxbox1 ~]$ ssh-keygen -b 2048 -t rsa

Generating public/private rsa key pair.
Enter file in which to save the key (/home/utente/.ssh/id_rsa):
Created directory '/home/utente/.ssh'.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/utente/.ssh/id_rsa.
Your public key has been saved in /home/utente/.ssh/id_rsa.pub.
The key fingerprint is:
90:98:4f:f5:69:39:57:5d:46:83:a4:a2:d6:63:3c:25 utente@linuxbox1

A questo punto dovremmo copiare la chiave pubblica sul server SSH. Questa essendo pubblica può essere letta da chiunque, senza problemi di sicurezza. Per copiarla possiamo usare anche scp, programma per la copia di SSH. Ipotizzando che il server si chiami linuxbox2 e che l'utente si chiami utente2, il comando sarà:

[utente@linuxbox1 ~]$ scp /home/utente/.ssh/id_rsa.pub utente2@linuxbox2:.

Ci verrà chiesta la password di utente2 e il file id_rsa.pub, contenente la chiave pubblica, verrà copiata nella home di utente2 su linuxbox2. A questo punto facciamo il login su linuxbox2 (ovviamente come utente2), e copiamo il contenuto del file appena copiato nel file /home/utente2/.ssh/authorized_keys:

cat /home/utente2/id_rsa.pub >> /home/utente2/.ssh/authorized_keys

altro sistema per copiare la mia chiave pubblica su un server remoto (al quale ho un accesso):

ssh-copy-id -i ~/.ssh/id_rsa.pub username@macchina.remota

oppure utilizzando il protocollo ssh
creare una directory ~/.ssh come utente2 su Linuxbox2. (La directory potrebbe gia' esistere, il che va bene...):

utente@linuxbox1:~> ssh utente2@linuxbox2 mkdir -p .ssh
utente2@linuxbox2's password:

Ora appendi la nuova chive pubblica di utente su utente2@linuxbox2:.ssh/authorized_keys ed inserisci la password di utente2 per l'ultima volta:

utente@linuxbox1:~> cat .ssh/id_rsa.pub | ssh utente2@linuxbox2 'cat >> .ssh/authorized_keys'
utente2@linuxbox2's password:

A questo punto basterà provare a collegarsi dall'host linuxbox1 su linuxbox2 per connettersi a patto di inserire la passphrase scelta :

ssh utente2@linuxbox2

Backup incrementale con tar

Una funzionalità di tar non molto usata è quella degli archivi incrementali. E’ invece una funzionalità che può risultare molto utile in alcune strategie di backup, quando, ad esempio, si esegue un ciclo di backup su base settimanale ma non si vuole o non si può fare un backup completo ogni giorno.

Supponiamo ad esempio di voler fare il backup della directory /home/documenti salvando l’archivio in /var/backup. Il comando da dare è:

tar zcvf /var/backup/documenti-`date +%s`.tgz --listed-incremental=/var/log/documenti.tarlog /home/documenti

Viene cioè creato un’archivio dal nome documenti-.tgz (per esempio: documenti-1180427502.tgz), che contiene tutto quello che c’è in /home/documenti. La scelta di aggiungere la data in formato unix è totalmente arbitraria e serve solo come promemoria. Può essere usata al suo posto la data in formato normale usando +%F al posto di +%s.

Viene inoltre creato un file di log (/var/log/documenti.tarlog) che servirà a tar nei successivi backup per capire cosa è cambiato in /home/documenti e cosa va quindi inserito nei successivi backup.

Nei successivi archivi creati con lo stesso comando verranno inseriti solo i file nuovi o modificati e verrà aggiornato il file di log.

Cancellando il file di log e rilanciando il comando viene ricreato un archivio completo. Tutti gli archivi creati, quelli completi e quelli incrementali, hanno il grosso vantaggio di poter essere trattati individualmente, cioè non c’è bisogno della presenza del file di log per poter estrarre i files e le directory in essi contenuti.

Nella pratica se la directory /var/backup viene salvata ogni notte dei giorni lavorativi su supporto esterno (tape, cd/dvd, nas etc.) un semplicissimo script /usr/local/bin/backup_documenti.sh che utilizzi la funzionalità incrementale di tar potrebbe essere scritto in questo modo:

#!/bin/sh
# Cancella i vecchi archivi presenti
rm /var/backup/documenti-*.tgz
# prepara il nuovo archivio, completo se il file di log
#non esiste, altrimenti incrementale
tar zcvf /var/backup/documenti-`date +%s`.tgz --listed-incremental=/var/log/documenti.tarlog /home/documenti

Ovviamente se serve avere il file completo e gli incrementali la cancellazione degli archivi la facciamo nello script che parte il lunedì.

Lo scipt va lanciato tramite cron ogni giorno prima che il sistema di backup archivi la directory sul supporto esterno. Il primo giorno della settimana, prima che venga archiviata la directory dei documenti, sempre tramite cron, viene cancellato il file di log, in modo che il primo backup della settimana sia sempre completo.

Le righe da inserire in un crontab possono essere simili a queste:

#lunedì sera alle 21 cancello il file di log prima
#che cominci l'archiviazione
0 21 * * 1 rm -f /var/log/documenti.tarlog
# dal lunedì al venerdì alle 22 viene preparato
#il file archivio
0 22 * * 1-5 /usr/local/bin/backup_documenti.sh

nfs su ubuntu

Introduzione

NFS sta per Network File System e indica un filesystem distribuito, ovvero condiviso fra un certo numero di nodi di una rete.

Alla base di questa tecnica c'è la necessità di accedere e lavorare sulle proprie risorse anche se non si è davanti al proprio computer.

La delocalizzazione delle informazioni porta tuttavia con sè tutta una serie di problematiche, prima delle quali vi è la coerenza dello stato delle informazioni ed il controllo della sincronizzazione delle modifiche effettuate (poichè UNIX è un sistema operativo multiutente ad un dato istante di tempo N utenti possono tentare di accedere in scrittura ad uno stesso file).

Installazione

Per installare il supporto per nfs lato kernel digitare:

sudo apt-get install nfs-kernel-server

Configurazione di NFS lato server

Il pacchetto necessario per il setup del servizio NFS di filesystem distribuito su Linux è nfs-kernel-server che viene gestito con i comandi da shell

/etc/init.d/nfs-kernel-server start|stop|restart|status

I servizi correlati con nfs sono :

/sbin/portmap: gestibile con il comando

/etc/init.d/portmap start | stop | restart

/etc/init.d/nfs-common

/etc/init.d/nfs-kernel-server

Il file di configurazione lato server è /etc/exports la cui sintassi è della seguente forma:

[directory da esportare] [host a cui esportarla] ([permessi])

Un esempio è il seguente :

/home/administrator *.pascal.org(ro) sola lettura sostituire ro con rw per lettura scrittura

Questo dice al server NFS di permettere a tutti i client del dominio pascal.org di accedere al filesystem in /home/administrator in modalità di sola lettura.

Il comando da usare per esaminare i fs montati è :

showmount

Per aumentare la sicurezza e la protezione del vostro server NFS dovrete definire la protezione servizi RPC lato server. Il file da editare è /etc/hosts.allow. Il formato di questo file è il seguente:

Programma:hosts:permissions

Ad esempio:

portmap:ALL EXCEPT .org:DENY

Nega a tutti gli hosts tranne quelli del dominio org l'accesso via RPC al file system distribuito NFS.

Configurazione dei clients

Il client che voglia accedere ad una risorsa NFS deve soltanto decidere come montare tale risorsa , se manualmente tramite il comando mount oppure automaticamente ad ogni avvio inserendo mount point e host nel file /etc/fstab.

Personalmente non consiglio quest'ultima soluzione poichè anche cercando di ottimizzare si va incontro a notevoli problemi di stabilità e sicurezza dei propri sistemi.

Come montare le risorse esportate:

Esempio: host B vuole temporaneamente montare la directory /home/administrator condivisa da host A sul suo fs locale /media/exported.

Il Comando su host B :

mount -t nfs hostA:/home/administrator /media/exported

La cartella /media/exported deve essere già creata e disponibile, come questa lo deve essere qualsiasi altra cartella che si desideri utilizzare.

Come fare se host B vuole montare sempre al boot la directory remota condivisa da host A?

Modificare il file /etc/fstab su hostB aggiungendo la seguente riga:

hostA:/home/administrator /media/exported nfs ro 0 0

disinstallare grub2 e installare grub ubuntu 9.04

Prima di tutto scaricate una distribuzione live tipo Ubuntu 9.04 o succcessive (obbligatorio in caso di filesystem ext4) dopo aver verificato la presenza del collegamento internet eseguire quanto segue Code: sudo fdisk -l Dispositivo Boot Start End Blocks Id System /dev/sda1 * 1 2496 20049088+ 83 Linux /dev/sda2 2497 2610 915705 5 Esteso /dev/sda5 2497 2610 915673+ 82 Linux swap / Solaris con questo comando si riesce a vedere su quale disco viene eseguito il boot nel nostro caso su sda1 dopo aver verificato questo eseguire i seguenti comandi: Code: sudo mount /dev/sda1 /mnt sudo mount --bind /dev /mnt/dev sudo mount --bind /proc /mnt/proc sudo chroot /mnt apt-get purge grub2 apt-get install grub Se i comandi in precedenza non creano errori si continua così: Code: mv /boot/grub/menu.lst /boot rm -fr /boot/grub grub-install /dev/sda update-grub cat /boot/grub/menu.lst exit Dopo aver lanciato update-grub alla richiesta premere "S" o "y" per creare un nuovo menu.lst, se anche questo termina correttamente si può riavviare ed il gioco è fatto.