Category: linux

  • VMWare Fusion e Ubuntu: risoluzione dello schermo fissa a 1280×720. Ecco come risolvere la situazione

    Dopo aver aggiornato la macchina virtuale con Ubuntu 10.10 in VMWare Fusion, mi sono trovato impossibilitato a selezionare una risoluzione superiore a 1280×720.

    Anche dopo aver reinstallato i VMWare Tools, la risoluzione disponibile era sempre bloccata a 1280×720. Dopo aver fatto qualche ricerca nei log, ho trovato alcuni messaggi che evidenziavano il problema:
    could not apply the stored configuration for monitors
    Xserver does not support size requested
    VESA(0): Unable to estimate virtual size
    VESA(0): Not using built-in mode "2048x1536" (no mode of this name)
    VESA(0): Not using built-in mode "1920x1440" (no mode of this name)
    VESA(0): No valid modes left. Trying less strict filter...
    VESA(0): : Using hsync range of 31.50-37.90 kHz
    VESA(0): : Using vrefresh range of 50.00-70.00 Hz
    VESA(0): Unable to estimate virtual size
    VESA(0): Not using built-in mode "2048x1536" (hsync out of range)
    VESA(0): Not using built-in mode "1920x1440" (hsync out of range)
    VESA(0): Virtual size is 1280x720 (pitch 1280)

    Il problema risiede nella configurazione e nel rilevamento della risoluzione dello schermo; il pacchetto incriminato è quindi xserver-xorg-video-vmware. Per risolvere è sufficiente aprire un terminale e digitare:

    1. sudo apt-get remove xserver-xorg-video-vmware
    2. sudo apt-get install xserver-xorg-video-vmware
    3. fate un logout e un login, e la risolzione ottimale verrà ripristinata
  • Come mantenere attiva una sessione SSH (keepalive)

    Quando ci connettiamo tramite ssh ad un server remoto, nella maggior parte dei casi la connessione viene terminata dopo un periodo di inattività (idle), e siamo quindi costretti a riconnetterci al server.

    La disconnessione può essere dovuta ad una serie di ragioni; la più verosimile, nel caso di inattività, è quella che un nodo intermedio abbatta la connessione (trascorso un certo periodo di tempo il cui il traffico scambiato è nullo) per mantenere basso il numero di connessioni (e quindi risparmiare risorse). Questo comportamento è perfettamente legittimo (quasi tutti i dispositivi e i provider implementano questa funzionalità).

    Possiamo però evitare questo comportamento abilitando il keepalive di SSH. facendo in modo che SSH scambi del traffico “fittizio” quando la connessione non sta scambiando dati, in modo che la connessione non venga abbattuta. Nota: questa funzionalità è disabilitata di default da ssh.

    Abilitare questo comportamento è molto semplice, e può essere ottenuto in due modi:

    • Se vogliamo abilitare il keepalive per tutti gli utenti, dovremo avere accesso root alla macchina. Modifichiamo il file /etc/ssh/ssh_config e aggiungiamo queste righe:
      ClientAliveInterval 300
      ClientAliveCountMax 1000
    • Se vogliamo abilitare il keepalive solo per l’utente corrente, modifichiamo il file ~/.ssh/config e aggiungiamo queste righe:
      ClientAliveInterval 300
      ClientAliveCountMax 1000

    In questo modo, il server ssh invierà un messaggio di keep-alive nel caso in cui la connessione ssh non scambi dati per 5 minuti (300 secondi), e ripeterà l’invio per massimo 1000 volte.

  • Ubuntu: come convertire il file-system ext3 in ext4 [non-root fs]

    Con l’uscita della nuova versione di Ubuntu ho deciso di convertire i file-system che (ahimé) avevo ancora in ext3 a ext4, per guadagnarne in performance ed affidabilità senza però formattare la partizione (e perdere i miei dati).

    [Una piccola nota: non sono un grande fan di ext*, infatti come sapete sono un grande sostenitore di XFS, ma la conversione ext3->XFS non è stata ancora implementata.]

    Vediamo la procedura per convertire da ext3 a ext4 un file-system non-root, ovvero su cui non risiede la root / del vostro filesystem. I dati nella partizione sono al sicuro e non verranno intaccati (in ogni caso consiglio sempre di avere un backup recente a portata di mouse).

    Andiamo con ordine:

    1. Identifichiamo la partizione non-root che vogliamo convertire, (nel mio caso /media/store e quindi /dev/sdb1): michele@cletus:~$ mount | grep ^/dev/
      /dev/sda2 on / type ext3 (rw,relatime,errors=remount-ro)
      /dev/sdb1 on /media/store type ext3 (rw)
    2. Facciamo un unmount della partizione che vogliamo convertire: unmount /media/store
    3. Lanciamo un controllo preventivo del file-system per prepararlo alla conversione: fsck.ext3 -pf /dev/sdb1 (ovviamente da qui in avanti sostituite la partizione che avete identificato al punto 1 a /dev/sdb1)
    4. Se il controllo è terminato senza problemi possiamo passare alla conversione vera e propria: tune2fs -O extents,uninit_bg,dir_index /dev/sdb1
    5. Rilanciamo un controllo del file-system, per controllare che tutto sia andato per il verso giusto: fsck -pf /dev/sdb1
    6. Apriamo il file /etc/fstab, modificando con “ext4” il tipo di file-system per la entry relativa a /media/store
    7. Possiamo rimontare la partizione: sudo mount /media/store

    L’operazione è assolutamente trasparente, nel senso che i dati non sono stati intaccati e la partizione viene ora riconosciuta come ext4:

    michele@cletus:~$ mount | grep ^/dev/
    /dev/sda2 on / type ext3 (rw,relatime,errors=remount-ro)
    /dev/sdb1 on /media/store type ext4 (rw)

    L’operazione è anche molto veloce: per convertire un volume da 500 GB (SATA) sono richiesti circa 40 minuti.

  • Trenitalia e Viaggiatreno: come implementare un servizio “fai da te” per avere le informazioni dello stato di un treno via SMS

    Da quando sono diventato un pendolare (per lavoro), ho iniziato a (ri)frequentare assiduamente le stazioni ferroviarie e i treni di Trenitalia.

    station.

    Dopo un paio di settimane passate sui treni, mi sono accorto di un servizio interessante: il sito Viaggiatreno: il sito contiene le informazioni sui treni (informazioni in tempo reale sullo stato di un treno come ritardo o anticipo, ora prevista di arrivo e fermate già effettuate).

    Esigenza

    Dopo aver provato il disagio di un treno soppresso (e quindi essermi svegliato un’ora prima per stare un’ora ad aspettare in stazione), mi sono reso conto di poter, perlomeno, arginare il problema se si fosse presentato in futuro; conoscere lo stato del treno direttamente sul telefonino mi permetterebbe, la mattina, di poter scegliere un mezzo alternativo senza recarmi in stazione nel caso in cui il treno sia in ritardo o soppresso. Oppure, se il treno è in anticipo, di accelerare i tempi.

    Soluzioni esistenti

    • Potrei controllare il sito Viaggiatreno accedendo il computer, connettendomi a Internet e andando sul sito Viaggiatreno. Contro: il tempo richiesto è troppo (~ 5 minuti. E la mattina anche 5 minuti sono preziosissimi).
    • Potrei installare su iPhone l’applicazione ProntoTreno, un’applicazione che fornisce lo stato di tutti i treni in tempo reale. Contro: il mio access point WIFI non è sempre attivo; non ho a disposizione la connessione 3G. Inoltre, se dovessi cambiare telefono per passare ad un telefono senza WIFI/3G, questa soluzione non è più applicabile.

    L’idea

    Il mezzo da utilizzare è sicuramente il mobile. L’incognita era semplicemente trovare il modo per raggiungere i telefoni, ed è stato individuato negli SMS, supportati da tutti i telefoni.

    L’altro fattore da tenere in considerazione è: come ottenere i dati da Viaggiatreno? Il sito utilizza Flash, ed estrarre informazioni testuali e puntuali da Flash penso sia infattibile. La soluzione è presto trovata: fortunatamente, Viaggiatreno offre anche una versione mobile, realizzata in (X)HTML, per la gioia dei parser.

    La realizzazione

    Per la realizzazione del servizio abbiamo bisogno di:

    • Un server Linux attivo e connesso a Internet durante il lasso di tempo in cui vogliamo essere avvisati via SMS. Inoltre, il server Linux deve avere installato crontab, l’interprete python e alcuni pacchetti python che vedremo più avanti.
    • Un servizio per mandare SMS gratuitamente: io mi appoggio a virgilio.it, che mi permette di ricevere via sms tutte le email ricevute all’indirizzo indirizzo@sms.tin.it [per i più impazienti: in questo modo per ricevere SMS è sufficiente mandare una mail]. Se invece non potete usare virgilio.it, vi raccomando di utilizzare MoioSMS per l’invio gratuito di SMS.
    • Un account GMail da cui mandare la mail del punto sopra (se siete degli smanettoni, non avete bisogno di questo e potrete usare il vostro SMTP, a patto di sostituirlo nel codice).
    • Un telefono mobile abilitato alla ricezione di SMS e attivo (ovviamente!)
    • Il numero del treno di nostro interesse: per conoscere il numero del treno, è sufficiente andare su TreniItalia, immettere partenza e arrivo e annotarsi il numero del treno. Il numero del treno è unico e non cambia.
    • Lo script python seguente, che ho scritto in Python utilizzando le librerie python-mechanize e python-beautifulsoup (installatele seguendo la guida per la vostra distribuzione. Per Ubuntu/Debian ho usato apt-get install python-mechanize python-beautifulsoup). Il codice è ancora immaturo, ma funziona (vedi screenshot):
      “`
      #! /usr/bin/python

      import BeautifulSoup
      import mechanize
      import smtplib
      import time
      import datetime
      from email.MIMEMultipart import MIMEMultipart
      from email.MIMEBase import MIMEBase
      from email.MIMEText import MIMEText
      from email import Encoders
      import os
      import sys

      gmail_user = "gmail username"
      gmail_pwd = "gmail pass"

      def mail(to, subject, text):
      msg = MIMEMultipart()

      msg['From'] = gmail_user
      msg['To'] = to
      msg['Subject'] = subject

      msg.attach(MIMEText(text))

      mailServer = smtplib.SMTP("smtp.gmail.com", 587)
      mailServer.ehlo()
      mailServer.starttls()
      mailServer.ehlo()
      mailServer.login(gmail_user, gmail_pwd)
      mailServer.sendmail(gmail_user, to, msg.as_string())
      mailServer.close()

      numtreno = sys.argv[1]
      stazione = sys.argv[2]

      tobeparsed = mechanize.urlopen(str(str('https://mobile.viaggiatreno.it/viaggiatreno/mobile/scheda?numeroTreno=') + str(numtreno) + str('&tipoRicerca=numero&lang=IT')))
      f = BeautifulSoup.BeautifulSoup(tobeparsed)
      f = f.prettify()
      f = f[f.find('<!– SITUAZIONE –>'):]
      f = f[:f.find('</div>')]
      s1 = f[f.find('<strong>')+len('<strong>'):f.find('<br />')]
      s2 = f[f.rfind('–>')+len('–>'):f.find('</strong>')]
      s1 = s1.replace(''',"'")
      s1 = s1.split()
      s2 = s2.split()
      tobeparsed = mechanize.urlopen(str(str('https://mobile.viaggiatreno.it/viaggiatreno/mobile/scheda?dettaglio=visualizza&numeroTreno=') + str(numtreno) + str('&tipoRicerca=numero&lang=IT')))
      f = BeautifulSoup.BeautifulSoup(tobeparsed)
      f = f.prettify()
      f = f[f.find(stazione):]
      f = f[:f.find("</div>")]
      arr1 = f[f.find('')+len('<p>'):f.find('<br />')]
      or1 = f[f.find('<strong>')+len('<strong>'):f.find('</strong>')]
      arr = f[f.rfind('<p>'):f.rfind('</p>')]
      arr2 = arr[arr.find('<p>')+len('<p>'):arr.find('<br />')]
      or2 = arr[arr.find('<strong>')+len('<strong>'):arr.find('</strong>')]
      arr1 = arr1.split()
      or1 = or1.split()
      arr2 = arr2.split()
      or2 = or2.split()
      arr1.extend(or1)
      arr2.extend(or2)

      L = [s1, s2, arr2]
      for i in xrange(len(L)):
      L[i] = ' '.join(L[i])
      message = '\n'.join(L)

      mail("indirizzo@sms.tin.it",
      sys.argv[1],
      message,
      )
      “`

      Il codice estrae le informazioni di interesse da Viaggiatreno mobile (come detto, per fare il parsing occore usare il sito in versione mobile) come lo stato corrente del treno (posizione ed eventuali minuti di ritardo o anticipo) e l’orario di arrivo previsto e manda queste informazioni all’indirizzo mail “speciale” che gira il messaggio al mio numero di cellulare via SMS [per l’invio della mail il servizio usa GMail]. Come detto, potreste usare MoioSMS (via pipe o python import) semplicemente sostituiendo la parte di invio della mail.

    Come si utilizza?

    • Lo script accetta due parametri da command-line: il numero di treno a cui siete interessati e la stazione di cui volete conoscere l’orario di arrivo stimato (es. “LECCO MAGGIANICO”).
    • Modificate, nello script le variabili gmail_user e gmail_password con le credenziali del vostro account GMail che useremo per spedire la mail verso l’indirizzo speciale che girerà le mail in SMS. Sempre nel codice, sostituite appunto indirizzo@sms.tin.it con il vostro indirizzo “speciale” che tramuta il messaggio e-mail in SMS.
    • Usando crontab, inserite una entry del tipo:
      08 07 * * 1-5 python /home/mbologna/parser.py 5033 “LECCO MAGGIANICO”
      Per avere un aggiornamento via SMS alle 07:08 di tutti i giorni feriali del treno 5033 specificando che deve fornirci l’orario di arrivo previsto alla stazione di “LECCO MAGGIANICO”.

    Risultati

    La mattina, prima di recarmi in stazione, controllo sul mio telefono e automaticamente ricevo 3 SMS gratuiti diversi contenenti lo stato del treno man mano che si avvicina alla stazione in cui io salgo sul treno. In questo modo, ancora prima di uscire di casa, posso sapere se il treno è in ritardo o se è stato soppresso.

    Qui accanto, la testimonianza di 2 degli SMS che ricevo quotidianamente.

    Sviluppi futuri

    • Miglioramento del codice di download/parsing
    • Integrazione con MoioSMS

    Curiosità

  • Cheese: un’applicazione per fare fotografia con la webcam per Ubuntu [un clone di Photo Booth]

    imageSe state cercando un’alternativa a Photo Booth, il popolare software di Apple per scattare fotografie tramite la webcam del proprio computer, allora dovreste considerare Cheese.

    Si tratta di un programma molto semplice: una volta aperto, mostra l’immagine della webcam e vi permette di scattare una foto. Inoltre, è possibile applicare alcuni effetti “simpatici” [le foto sono degli sviluppatori di Gnome/Cheese].

    Cheese è incluso nei repository di Ubuntu, quindi per installarlo è sufficiente digitare: sudo apt-get install cheese

    Senza dubbio da provare!

  • Ubuntu: Apache2 con certificati self-signed e senza password all’avvio

    Recentemente mi è capitato di dover installare apache [in particolare, apache2] su una macchina Ubuntu. In particolare, mi è stato chiesto di installare la versione con ssl, ovvero che implementa il protocollo cifrato https.

    Apache2+ssl richiede l’utilizzo di un certificato firmato da un’autorità [es. Thawte, Verisign, etc.]. Se non vogliamo pagare una CA per ottenere un certificato firmato, possiamo generare un certificato firmato da noi stessi. Tuttavia, seguendo molte delle guide che si trovano in rete, apache viene installato con l’opzione ssl ma ogni volta che viene avviato richiede la password per l’utilizzo del certificato.

    Per questo riporterò qui una guida passo-passo che fa in modo che Apache2 non richieda la password per l’utilizzo del certificato: questa procedura è consigliata solamente se l’utilizzo è volto al testing o allo sviluppo. Qualsiasi altro uso è sconsigliato [richiedere una password per l’utilizzo del certificato è più che normale].

    • Abilitate il modulo ssl per apache2: sudo a2enmod ssl
    • Generiamo il certificato: cd /tmp; sudo openssl req -new > new.cert.csr
    • Vi verranno chieste delle informazioni a scopo puramente informativo e che compariranno nel certificato. Riempite le varie informazioni come credete
    • Ed ora una serie di comandi per generare tutti i file richiesti dai certificati: sudo openssl rsa -in privkey.pem -out new.cert.key
      sudo openssl x509 -in new.cert.csr -out new.cert.cert -req -signkey new.cert.key -days 1825
      sudo cp new.cert.cert /etc/ssl/certs/server.crt
      sudo cp new.cert.key /etc/ssl/private/server.key
    • Ora abilitiamo l’utilizzo dei certificati appena generati:sudo cp /etc/apache2/sites-available/default /etc/apache2/sites-available/ssl
    • Modificate il file /etc/apache2/sites-available/default con il vostro editor preferito, ad esempio vi: sudo vi /etc/apache2/sites-available/default e cambiate le seguenti linee:
      Cambiare da…A…
      NameVirtualHost: *NameVirtualHost: *:80
      <VirtualHost *><VirtualHost *:80>
    • Modificate ora il file /etc/apache2/sites-available/ssl sempre con il vostro editor preferito e cambiate le seguenti linee:
      Cambiare da…A…
      NameVirtualHost: *NameVirtualHost: *:443
      <VirtualHost *><VirtualHost *>

      Dopo la linea che contiene DocumentRoot, aggiungete le seguenti righe:

      SSLEngine on
      SSLOptions +StrictRequire
      SSLCertificateFile /etc/ssl/certs/server.crt
      SSLCertificateKeyFile /etc/ssl/private/server.key
      
    • Ora date il seguente comando per abilitare l’utilizzo dei certificati in apache2: sudo a2ensite ssl
    • Infine riavviate Apache2 e finalmente non chiederà più la password del certificato: sudo /etc/init.d/apache2 restart

    Nota: se avete problemi controllate che il vostro file /etc/hosts sia fatto in questo modo:

    127.0.0.1 localhost localhost.localdomain {il vostro hostname}
    127.0.1.1 {il vostro hostname}
    {IP statico se ne avete uno} {DNS fully qualified se ne avete uno}
  • Come impostare ssh in modo che non richieda la password di accesso (chiavi asimmetriche per il login)

    Alcuni client ssh permettono di definire “sessioni salvate” di connessioni in modo che username e password vengano salvati e non vengano richiesti ad ogni connessione verso un host. Trovo che permettere all’utente di poter salvare la password sia profondamente sbagliato dal punto di vista della security, soprattutto se l’utente ha privilegi non indifferenti sulla macchina remota [ad esempio è nei sudoers].

    Detto questo, trovo anche che sia abbastanza noioso inserire la propria password ad ogni connessione. Ma non disperate: il meccanismo standard per risparmiarvi preziosi secondi esiste e ve lo spiegherò tra poco. Inoltre, il meccanismo standard è sicuro di per sé e non indebolisce la struttura di ssh perché utilizza un’autenticazione basata sulla crittografia asimmetrica.

    Innanzitutto: queste istruzioni sono per Linux e OSX. In futuro posterò anche le istruzioni per Windows/PuTTY.

    Obiettivo: loggarsi dalla macchina locale (local) alla macchina remota (remote) senza inserire la password

    Sulla macchina locale: generare le chiavi di autenticazione [1/2]

    Le chiavi di autenticazione sono composte da 2 chiavi, una pubblica e una privata. La chiave pubblica rappresenta la nostra identità nel mondo esterno. La chiave privata, invece, rappresenta la nostra chiave segreta, la nostra “password” [anche se è molto più lunga di una password].

    Per generare le chiavi bisogna dare questo comando:
    local$ ssh-keygen -t rsa
    Generating public/private rsa key pair.
    Enter file in which to save the key (/home/mbologna/.ssh/id_rsa):

    Accettate il path che vi viene proposto premendo Invio
    Enter passphrase (empty for no passphrase):
    Enter same passphrase again:

    Vi consiglio fortemente di inserire una password a questo punto. Nonostante molte persone consiglino (sbagliando) di non inserire una password perché si ripeterebbe il problema di dover inserire una password, vi posso assicurare che impostare un ulteriore livello di sicurezza per poter accedere ad un file così delicato come la vostra chiave privata è più che consigliato [e per sfatare un falso mito: non è vero che bisogna reinserire la password, basta affidarsi a un’implementazione sicura di ssh-agent].

    Ora controllate che effettivamente il comando abbia creato le vostre chiavi:

    local$ ls -la .ssh/
    drwx------  2 mbologna mbologna   4096 2009-09-24 18:43 .
    drwx------ 55 mbologna mbologna   4096 2009-11-13 00:42 ..
    -rwx------  1 mbologna mbologna   1743 2009-08-04 16:52 id_rsa
    -rwx------  1 mbologna mbologna    433 2009-08-04 16:52 id_rsa.pub

    id_rsa contiene la vostra chiave privata, mentre id_rsa.pub contiene la vostra chiave pubblica.

    Sulla macchina remota: autorizzare l’autenticazione tramite chiave pubblica [2/2]

    Loggatevi sulla macchina remota inserendo la vostra password [per l’ultima volta :)]:

    local$ ssh username@remote
    A questo punto seguite i seguenti passi:

    • create una directory .ssh nella vostra home mkdir .ssh
    • impostate i permessi appropriati chmod 700 .ssh
    • spostatevi nella directory .ssh cd .ssh
    • create un file chiamato authorized_keys touch authorized_keys
    • impostate i permessi approppriati chmod 600 authorized keys
    • aprite il file authorized_keys con il vostro editor preferito [ad esempio vi] vi authorized_keys
    • copiate e incollate il contenuto del file ~/.ssh/id_rsa.pub presente su local nel file authorized_keys
    • fate un logout

    Abbiamo finito! Ora potete semplicemente loggarvi sulla macchina remote semplicemente con ssh username@remote

    Nota: se non volete digitare la password ogni volta che accedete alla vostra chiave privata, date un’occhiata a ssh-agent.

  • Ubuntu e Debian: come aggiornare automaticamente i pacchetti installati (unattended-upgrades)

    Nella vita di un sistemista esiste un task piuttosto ripetitivo: ovvero quello di aggiornare i pacchetti (= gli applicativi) installati sul proprio sistema (vuoi perché le versioni recenti dello stesso software dovrebbero essere migliori, più performanti e al riparo dagli ultimi bug di security, etc.).

    Nel caso di un sistemista alle prese con un sistema Ubuntu (o Debian), il task [da eseguire ripetutamente] si riduce a:
    apt-get update
    apt-get dist-upgrade

    (o comunque equivalente se usate aptitude).

    Ora, per evitare di ripetere il task, i sistemi Ubuntu/Debian mettono a disposizione unattended-upgrades: una volta installato il pacchetto, il sistema provvederà ad aggiornare e installare automaticamente tutte le applicazioni installate nel sistema. Vediamo come installare e configurare passo-passo unattended-upgrades:

    1. apriamo un terminale e installiamo il pacchetto unattended-upgrades: apt-get install unattended-upgrades update-notifier-common
    2. editiamo il file /etc/apt/apt.conf.d/50unattended-upgrades in questo modo:

      Automatically upgrade packages from these (origin, archive) pairs
      Unattended-Upgrade::Allowed-Origins {
      "Ubuntu hardy-security";
      "Ubuntu hardy-updates";
      };

    3. editiamo il file /etc/apt/apt.conf.d/10periodic in questo modo:

      APT::Periodic::Update-Package-Lists "1";
      APT::Periodic::Download-Upgradeable-Packages "1";
      APT::Periodic::AutocleanInterval "1";
      APT::Periodic::Unattended-Upgrade "1";

    A questo punto i pacchetti installati nel sistema verranno aggiornati automaticamente.

    Nota: è sempre opportuno controllare i log degli aggiornamenti per evitare eventuali problemi. I log degli aggiornamenti si possono trovare, ovviamente, in /var/log/unattended-upgrades

  • Come impostare il pinning (non aggiornare, ovvero mantenere la versione attuale) di un pacchetto su Ubuntu/Debian

    A volte può capitare che su certe macchine Ubuntu (o Debian) alcuni pacchetti importanti non debbano essere aggiornati dal gestore di pacchetti (apt-get o aptitude). Le ragioni possono essere le più svariate: incompatibilità, volontà di tenere la versione corrente (!), aggiornamento manuale, etc.

    Per fare in modo che un pacchetto non venga mai aggiornato (ovvero che il sistema continui a mantenere la stessa versione del pacchetto installato, bisogna ricorrere alla tecnica del apt pinning, che ci consente di specificare al sistema che un pacchetto (o un gruppo di pacchetti) non deve essere aggiornato e deve essere tenuto “in hold”.

    Per fare in modo che un pacchetto non venga aggiornato basta aprire un terminale e digitare:

    echo nomepacchetto hold | dpkg --set-selections

    dove nomepacchetto è il nome del pacchetto di cui volete che non vengano scaricati aggiornamenti successivi rispetto alla versione installata correntemente.

    Per rimuovere il “blocco”, aprite un terminale e digitate:

    echo nomepacchetto hold | dpkg --set-selections

    dove nomepacchetto è il nome del pacchetto di cui volete che vengano scaricati aggiornamenti successivi rispetto alla versione installata correntemente.

  • Gentoo: creare una lista dei pacchetti e delle applicazioni installate

    Per chi utilizza Gentoo Linux e vuole conoscere quali pacchetti (e quindi quali applicazioni) sono installate basta semplicemente installare gentoolkit (emerge app-portage/gentoolkit) e poi utilizzare equery list.