Ltsp MueKow

Ltsp Mue Cow è l'evoluzione di ltsp 4.2 del quale vi avevo parlato nel post precedente dove troverete anche una descrizione di cosa è ltsp (La lettura del post è consigliata prima di procedere a leggere ciò che segue). Questa versione è quella presente nei repository ubuntu.

Installazione

Per l'installazione su ubuntu basta installare i pacchetti ltsp-server e ltsp-server-standalone. A questo punto da terminale digitiamo il comando:

sudo ltsp-build-client

Questo comando scaricherà da internet i pacchetti necessari alla costruzione dell'ambiente chroot.

Differenza con la versione 4.2: I pacchetti verranno scaricati direttamente dai repository ubuntu e fanno parte della distribuzione ubuntu e non sono creati appositamente come accadeva nella versione 4.2.

Note e differenze con la versione 4.2.

Importante: per default (per come è programmato il client) appena installiamo l'ambiente chroot il thin client non si avvia se non viene utilizzata come scheda di rete di avvio la eth0. Quindi se il thin client ha più schede di rete, ricordarsi di utilizzare la prima. Inoltre, oltre ai servizi già necessari per la versione 4.2, è necessario che il server ssh sia attivo ed è necessario verficare che nella directory etc/ssh dell'ambiente chroot (/opt/ltsp/i386/etc/ssh) nel file contente gli host conosiuti, la prima riga sia qualcosa di simile a nomeserver, indirizzo_ip_server ssh-rsa AAA... Se manca l'ip del server provvedere ad aggiugerlo a mano.

Appena installato l'ambiente chroot è privo di file di configurazione in /etc/lts.conf e utilizza le opzioni di default che includono l'uso del display manager ldm presente nel pacchetto ltsp-client. Ldm è scritto in python e utilizza un greeter sempre scritto in python. Il greeter è molto simile a gdm dal punto di vista dell'interfaccia. Esso viene lanciato dallo stesso ldm. Quando inseriamo l'usenrame e la password, il greeter le stampa sullo stdout che viene letto da ldm il quale procede ad avviare una sessione X attraverso un tunnel ssh. Viene così avviato l'ambiente desktop di default scelto dall'utente.

Volendo usare xdmcp occorre scrivere il file /etc/lts.conf (nell'ambiente chroot) in modo simile a:

[Default]
SCREEN_06=shell
SCREEN_07=startx

In questo modo nella console virtuale 7 viene avviato lo script startx presente sempre nel pacchetto ltsp-client. Nello sceen 6 ho attivato invece una shell.

Ltsp 4.2

Ltsp (linux terminal server project) è un progetto che permette di utilizzare vecchi computer anche senza disco e con poca ram come terminali in grado di connettersi ad un server (terminal server) e di avviarsi via rete. Il server compie tutte le operazioni "costose " in termini di processore e di ram ed il client semplicemene visualizza il risultato. E' possibile avviare intere sessioni di X compreso gnome, openoffice, firefox e tutto il resto utilizzando questo sistema. In questo post spiegherò passo passo come fare ad installare un terminal server utilizzando la versione 4.2 di ltsp. In un prossimo post vi spiegherò come installare la nuova versione presente anche nei repository ubuntu e le differenze con la 4.2.

Di cosa ho bisogno?

Prima di procedere è necessario scaricare dal sito ufficiale di ltsp http://wiki.ltsp.org/twiki/bin/view/Ltsp/LTSP-42 il pacchetto ltsp-utils_0.25_all.deb che è l'ultima versione nel momento in cui sto scrivendo questo post. Installiamo il pacchetto con:

sudo dpkg -i ltsp-utils_0.25_all.deb

Quindi installiamo tutti gli altri pacchetti necessari direttamente dal repository ubuntu:

• dhcp3-server
• dhcp3-common
• tftpd-hpa
• nfs-kernel-server
• xinetd
• libwww-perl

Installazione

Dopo aver installato tutti i pacchetti necessari, lanciamo da root il comando ltspadmin Seguiamo il wizard fino alla fine. Un altro comando utile è ltspcfg che ci permette do controllare lo stato dei servizi necessari e di impostare la configurazione di base. Assicuriamoci che le impostazioni della rete e i percorsi siano corretti nel file di configurazione del server dhcp /etc/dhcp3/dhcpd.conf. A questo punto dobbiamo assicurarci che tutti i servizi siano attivi. Quindi attiviamo il server dhcp, il servizio portmap necessario ad nfs, nfs. Per abilitare il servizio tftp creiamo il file /etc/xinet.d/tftp con questo contenuto:

service tftp
{
   disable         = no
   socket_type     = dgram
   protocol        = udp
   wait            = yes
   user            = root
   server          = /usr/sbin/in.tftpd
   server_args     =  -s /tftpboot
}

e riaviamo il servizio xinet.
Dobbiamo abilitare inoltre il servizio xdmcp. Per farlo se usiamo gdm dobbiamo editare il file /etc/gdm/gdm.conf cercare la sezione [xdmcp] e impostare enable su true. Quindi riavviamo gdm.

Come avviene il boot?

Di seguito spiegherò come avviene il boot usando il PXEclient della scheda di rete. Il client cerca un server dhcp nella rete. Il server dhcp oltre a fornire un ip al client, gli fornisce alcuni parametri necessari per effettuare il boot. Tra questi c'è un root-path che vedremo dopo a cosa serve, e il percorso al linux loader pxelinux. A questo punto il client carica il piccolo loader il quale a sua volta carica il kernel linux. I parametri del loader si trovano nel file /tftpboot/lts/[versione-kernel]/pxelinux.cfg/default Tra i parametri abbiamo root=/dev/ram0 e initrd=initramfs.gz. Ciò significa che non appena il kernel ha finito di avviarsi carica il il file initramfs.gz in ram, lo decomprime (è un archivio cpio compresso con gzip) e lancia il file linuxrc o init. In questo caso non essendo presente il file linuxrc lancia init che è uno script shell. Per vedere il contenuto di questo script bisogna decomprimere l'archivio in questo modo:

* gunzip initramfs.gz
* cpio -i -d -I initramfs

L'ultimo comando ricostrurà un albero delle directory stile unix. Lo script init presente nella radice dell'albero oltre ad altre operazioni, cerca per vedere se l'opzione root-path è stata fornita dal server dhcp, dando un errore altrimenti. Se l'opzione è presente e sia ad esempio:

option root-path              "192.168.50.1:/opt/ltsp/i386";

il percorso specificato verrà montato via nfs e dopo qualche altro comando, la directory sulla quale è stato montato diventerà la nuova root.

A questo punto il file importante è /opt/ltsp/i386/etc/lts.conf che nel mio caso è sotto la forma:

[Default]
    SERVER             = 192.168.50.1
    XSERVER            = auto
    X_MOUSE_PROTOCOL   = "PS/2"
    X_MOUSE_DEVICE     = "/dev/psaux"
    X_MOUSE_RESOLUTION = 400
    X_MOUSE_BUTTONS    = 3
    USE_XFS            = N
    SCREEN_01          = startx
    SCREEN_02          = shell

In pratica questo file viene utilizzato dallo script /opt/ltsp/i386/etc/rc.sysinit per lanciare il server X (client per l'xdmcp che gira sul terminal server) o una sessione telnet o altro. Nel mio caso ho aggiunto la variabile SCREEN_02 = shell che lancia una shell (busybox) direttamente sul thin client (non associata in alcun modo al terminal server). In questo modo su un terminale virutale ho la shell e sull'altro il server x
I valori associati alle variabili SCREEN sono degli script presenti nella directory /opt/ltsp/i386/etc/screen.d/

Google web toolkit sotto licenza Apache 2.0

La nuova versione 1.3 RC del gwt (google web toolkit) è stata rilasciata sotto la licenza open Apache 2.0. Il google web toolkit è un software che ci permette di scrivere in modo semplice applicazioni Ajax direttamente in java. Il compilatore gwt si preoccuperà di tradurre il nostro codice java in JavaScript ed Html compatibile con i maggiori browser (firefox, ie, safari, opera). La cosa bella è che non ci si deve preoccupare delle incompatibilità tra i vari browser. In teoria si potrebbe anche non conscere JavaScript affatto. Riporto un piccolo esempio direttamente dal sito per mostrare il modo di operare di gwt:

public class Hello implements EntryPoint {
public void onModuleLoad() {
 Button b = new Button("Click me", new ClickListener(){
   public void onClick(Widget sender) {
     Window.alert("Hello, AJAX");
   }
 });
 RootPanel.get().add(b);
}
}

Come si può vedere viene utilizzato un modo di programmare molto simile al modo classico utilizzato di solito in Java. I concetti sono gli stessi: pannelli, widgets, pulsanti etc. Insomma gwt appare come una astrazione al browser e alle sue teconologie riportando lo sviluppatore java ad un livello più familiare e semplice. Dal mio canto non sono mai stato un amante di java. Qualcuno di voi saprà che il mio linguaggio preferito resta quello del pitone, ma nonostante ciò trovo molto più semplice mettersi a programmare una applicazione web utilizzando il classico paradigma dei widgets piuttosto che impazzire con java script. Ancora non ho avuto purtroppo modo di testarlo (mancanza di tempo) Spero di poterlo fare presto per dirvi qualcosa in più.

Tip: bash e la storia dei comandi

Una funzione della shell bash che può risultare molto comoda è la ricerca nella storia dei comandi. Io l'ho scoperta da poco. In pratica basta premere Ctrl-R durante una sessione bash e vi apparirà questa riga:

(reverse-i-search)`':

Digitando qualche lettera bash inizia ad effettuare la ricerca stampandovi a video il comando che ha trovato. Premendo invio il comando viene eseguito. Premendo Ctrl-C la ricerca viene interrotta senza eseguire alcun comando.
Questa funzione è comodissima se avete digitato lunghi comandi tediosi da riscrivere e ricordare.

Un modulo portabile per suoni in python

Il modulo che vi riporterò di seguito serve per poter far emettere un suono al vostro programma python (in genere suoni brevi associati a particolari eventi) senza preoccuparvi se vi trovate su piattaforma windows o su linux chiamando una semplice funzione con parametro il nome del file da suonare.
Ecco un basilare esempio di utilizzo:

import sndplay

sndplay.play("percorso_del_file.wav")

Come avrete notato è molto semplice da usare. Se vi trovate su una piattaforma diversa dalle due supportate la funzione non fa nulla. Come parametro ho inserito un file wav. In realtà su linux viene accettato come parametro un qualsiasi formato supportato dalle librerie gstreamer ma se mettiamo un file diverso dal wav perdiamo la portabilità perché (almeno per ora) su windows è supportato solo il formato wav.

Passiamo ora al codice:

import threading
import os

(
    GSTPLAY,
    WINPLAY,
    NOENGINE
) = range(3)

try:
    import gst
    import gobject
    ENGINE = GSTPLAY
except ImportError:
    try:
            import winsound
            ENGINE = WINPLAY
    except ImportError:
            ENGINE = NOENGINE

class __GstPlayThread(threading.Thread):
    def __init__(self, ply):
            self.ply = ply
            threading.Thread.__init__(self)
    def run(self):
            self.ply.set_state(gst.STATE_PLAYING)
            def bus_event(bus, message):
                    t = message.type
                    if t == gst.MESSAGE_EOS:
                         self.ply.set_state(gst.STATE_NULL)
                    return True
            self.ply.get_bus().add_watch(bus_event)


def __gstplay(filename):
    cwd = os.getcwd()
    location = os.path.join(cwd, filename)
    ply = gst.element_factory_make("playbin", "player")
    ply.set_property("uri", "file://" + location)
    pt = __GstPlayThread(ply)
    pt.start()

def __winplay(filename):
    cwd = os.getcwd()
    location = os.path.join(cwd, filename)
    import thread
    def wplay():
            winsound.PlaySound(location,
 winsound.SND_FILENAME)
    thread.start_new_thread(wplay, ())

if ENGINE == GSTPLAY:
    play = __gstplay
    pass
elif ENGINE == WINPLAY:
    play = __winplay
else:
    def play(filename):
            pass

Attenzione: su linux è supportata solo la versione 0.10 delle pygst!!!

Come si può notare l'effettivo playing del file viene eseguito da un thread in modo che la play non sia bloccante. Cio vuol dire che mentre il suono viene riprodotto in background, il nostro codice può continuare ad essere eseguito ;)

Questo modulo l'ho scritto inizialmente per planimo ma ho pensato che sarebbe stato utile postarlo a parte con qualche spiegazione a contorno

Alice adsl e ubuntu

Vi è capitato di connettervi con alice adsl e avete avuto problemi?
Avete seguito la classica procedura con pppoeconf da console impostando correttamente i vostri dati, ma in seguito lanciando pon per andare online non riuscite a navigare? Se è questo il problema, controllate prima di tutto che l'interfaccia ppp0 sia stata creata correttamente lanciando da console il comando ifconfig (controllate che nell'output ci sia la voce ppp0). Se così non è questa guida non fa per voi. Se invece è così bisogna solo impostare il routing correttamente con:

sudo route add default dev ppp0

Samba: condividere files senza password

Come si fa a condividere files con samba senza password? Cioè fare in modo, ad esempio, che ad un utente windows quando prova ad accedere ai files condivisi non gli venga chiesto uno username ed una password?

La risposta è semplice. Bisogna editare il file di configurazione di samba /etc/samba/smb.conf, cercare l'opzione security ed impostarla a share

A questo punto basta condividere i files con il tool messo a disposizione da Ubuntu (cioè cliccando con il tasto destro su una cartella e scegliendo l'opzione Condividi cartella, oppure dal menu del pannello Sistema->Amministrazione->Cartelle condivise)
e quindi riavviare samba

Se vogliamo procedere a manina, sempre dal file di configurazione di samba possiamo aggiungere le varie sezioni. Esempio:

[shared]
path = /home/shared
guest ok = yes

Threads e gui pygtk: Soluzione definitiva

Se avete letto questo post vi avevo spiegato come usare
gtk.gdk.threads_init(), gtk.gdk.threads_enter() e
gtk.gdk.threads_leave().
Nel post successivo vi ho spiegato che quell'approccio però
penalizza la portabilità su windows. Ora per rendere il nostro codice
portabile potremmo utilizzare due diverse soluzioni. La prima che vi
propongo la mostro solo per completezza ma la sconsiglio e poi vi
spiegherò perché. La seconda è invece la più sicura ed è garanzia
di funzionamento anche in situazioni con più threads attivi.
Allora la prima soluzione consiste nell'eseguire le funzioni che danno
problemi con una gobject.idle_add() e "circondare" il main
con gtk.gdk.threads_enter() e gtk.gdk.threads_leave()
Il codice diventa (date uno sguardo qui per capire le differenze):

import threading
import time
import gtk
import gobject


gtk.gdk.threads_init()



class MyThread(threading.Thread):
  def __init__(self, pbar):
          self.pbar = pbar
          self.stop = False
          threading.Thread.__init__(self)

  def run(self):
          t = 0
          while not self.stop :
                  gtk.gdk.threads_enter()
                  # uso la idle_add
                  gobject.idle_add(self.pbar.set_fraction, t)
                  gtk.gdk.threads_leave()

                  t = t + 0.1
                  if t > 1.0:
                          t = 0.0

                  time.sleep(0.5)


def exit(arg):
  th.stop = True
  gtk.main_quit()

window = gtk.Window()
pbar = gtk.ProgressBar()
window.add(pbar)
window.show_all()

window.connect('destroy', exit)


th = MyThread(pbar)
th.start()

gtk.gdk.threads_enter()
gtk.main()
gtk.gdk.threads_leave()

Questo codice funziona anche su windows ma se i threads iniziano a diventare tanti ( ma non solo ) spesso si hanno dei problemi. Quindi se non volete impazzire vi consiglio vivamente questa seconda soluzione che consiste nell'evitare come la morte le varie threads_enter, threads_leave e init_threads e fare in modo che tutte le operazioni che hanno a che fare con le gtk vengano eseguite dallo stesso thread. L'esempio precedente può essere riscritto in questo modo:

import threading
import time
import gtk


class MyThread(threading.Thread):
    def __init__(self, main):
            self.main = main
            threading.Thread.__init__(self)

    def run(self):
            while not self.main.stop :
                    self.main.pbar_fraction += 0.1
                    if self.main.pbar_fraction > 1.0:
                            self.main.pbar_fraction = 0.0

                    time.sleep(0.5)

class Main:
    def __init__(self):
            self.pbar_fraction = 0
            self.stop = False

            window = gtk.Window()
            self.pbar = gtk.ProgressBar()
            window.add(self.pbar)
            window.show_all()
            window.connect('destroy', self.exit)

            th = MyThread(self)
            th.start()

            self.main_loop()

    def exit(self, arg):
            self.stop = True

    def main_loop(self):
            while not self.stop:
                    self.pbar.set_fraction(self.pbar_fraction)
                    while gtk.events_pending():
                            gtk.main_iteration()
                    time.sleep(0.01)

Main()

Come vedete non abbiamo usato neppure il gtk.main() e
il gtk.main_quit() ma facciamo tutto da noi ;)
Questo codice è portabile, funzionante e non vi farà imprecare :)

Download

Problema con gtk.gdk.threads_init()

Purtroppo la descrizione dell'utilizzo di questa funzione che ho fatto precedentemente sul blog sembra non funzionare sulla versione windows di python e delle pygtk.Il problema è che non appena si incontra la funzione gtk.gdk.threads_init(), il programma su windows si blocca e non c'è verso di farlo continuare. Purtroppo così i programmi scritti in pygtk perdono la loro caratteristica di portabilità.

Aggiornamento: qui propongo una soluzione

Threads e gui pygtk in python

Se vi è capitato di programmare con le gtk in python (e non solo) utilizzando i threads, vi sarete accorti che spesso vengono fuori problemi.

Perchè quel maledetto thread non riesce ad aggiornare la gui?

Facciamo un semplice esempio per capirci meglio.

import threading
import time
import gtk

class MyThread(threading.Thread):
      def __init__(self, pbar):
        self.pbar = pbar
        self.stop = False
        threading.Thread.__init__(self)

   def run(self):
        t = 0
        while not self.stop :
              self.pbar.set_fraction(t)
    
              t = t + 0.1
              if t > 1.0:
                      t = 0.0

              time.sleep(0.5)


def exit(arg):
  th.stop = True
  gtk.main_quit()

window = gtk.Window()
pbar = gtk.ProgressBar()
window.add(pbar)
window.show_all()

window.connect('destroy', exit)

th = MyThread(pbar)
th.start()

gtk.main()

Questo semplice programma non fa altro che creare una finestra gtk, aggiungergli un widget progressbar e creare un thread che aggiorna il progresso ogni mezzo secondo. Beh se provate ad eseguirlo, la finestra con la progress bar verrà creata ma non ci sarà alcun aggiornamento.

Il problema sta nel fatto che il thread, prova ad operare sull'oggetto gtk. Per fare ciò le librerie gtk prevedono una procedura particolare.
Prima di tutto va richiamata la funzione gtk.gdk.threads_init() prima della chiamata a gtk.main(). Poi ogni volta che si vuole accedere ad un oggetto gtk vanno usate le due funzioni:
gtk.gdk.threads_enter()
gtk.gdk.threads_leave()
Il codice corretto quindi è:

import threading
import time
import gtk

# chiamo threads_init()
gtk.gdk.threads_init()

class MyThread(threading.Thread):
  def __init__(self, pbar):
          self.pbar = pbar
          self.stop = False
          threading.Thread.__init__(self)

  def run(self):
          t = 0
          while not self.stop:
                  # threads_enter
                  gtk.gdk.threads_enter()
                  self.pbar.set_fraction(t)
                  # threads_leave
                  gtk.gdk.threads_leave()

                  t = t + 0.1
                  if t > 1.0:
                          t = 0.0

                  time.sleep(0.5)


def exit(arg):
  th.stop = True
  gtk.main_quit()

window = gtk.Window()
pbar = gtk.ProgressBar()
window.add(pbar)
window.show_all()

window.connect('destroy', exit)

th = MyThread(pbar)
th.start()

gtk.main()

Se lo eseguite vedrete la nostra progress bar finalmente in funzione!

Invio file su socket in python

In questo post spiegherò come è possibile inviare un file attraverso
la rete utilizzando i socket python. Quello che andremo a costruire
è un piccolo server che rimarrà in ascolto per ricevere un file che
verrà inviato da un client il quale lo preleverà dal disco rigido e lo
invierà via socket.
Ecco il codice del serverino che chiamiamo receive.py

#! /usr/bin/env/python

import socket
import sys

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('', 9900))
sock.listen(1)

filename = sys.argv[1]

s, addr = sock.accept()
file = open(filename, 'wb')
while 1:
   data = s.recv(1024)
   if not data: break
   file.write(data)
file.close()
s.close()

In pratica non fa altro che mettersi in ascolto sulla porta 9900 ed
aspettare la connessione da parte del client. Non appena il client
si connette, crea un file con il nome che gli è stato passato come
parametro e ci scrive dentro i dati inviatigli.

Vediamo ora il codice del client che chiamiamo send.py:

#! /usr/bin/env/python

import sys
import socket

filename = sys.argv[1]
host = sys.argv[2]

file = open(filename, 'rb')
sock = socket.socket(socket.AF_INET,
                             socket.SOCK_STREAM)
sock.connect((host, 9900))

while 1:
     data = file.read(1024)
     if not data: break
     sock.sendall(data)
file.close()
sock.close()

Il client apre il file passatogli come primo parametro e lo invia al
server (secondo parametro).
Come si può vedere si usa una normale sendall.
La documentazione python a riguardo potrebbe essere fuorviante.
Infatti viene indicato come sendall(string[, flags])
Cioè il primo parametro viene indicato come string mentre noi
vogliamo inviare un file binario generico. In realtà il metodo
funziona comunque perché la stringa in questo caso è intesa
un po come un array di char ovvero un array di bytes ;)

dvd e codecs su Ubuntu Edgy Eft

Come avrete notato non è presente nativamente in Ubuntu Edgy il
supporto alla visione dei dvd criptati e ne quello per i codecs
multimediali. Ne è possibile aggiungerlo dai repository ufficiali.
Per farlo bisogna seguire questi passi:
prima di tutto accertarsi di avere installato il pacchetto totem-xine
Poi installate il pacchetto libdvdread3 da synaptic e dopo
la libreria libdvdcss con il comando:

sudo  /usr/share/doc/libdvdread3/install-css.sh

Infine scaricate i codecs con:

wget -c http://www.debian-multimedia.org/pool/main/
         w/w32codecs/w32codecs_20061022-0.0_i386.deb

Il codice precedente va ricomposto su un'unica linea.
Installateli con:

sudo dpkg -i w32codecs_20061022-0.0_i386.deb

generare html con sintassi colorata

Ho scoperto un'altra cosa sul mio editor preferito :)
Volete generare html con sintassi colorata come in questo post?
E' molto semplice. In ubuntu basta installare vim-gnome con

sudo apt-get install vim-gnome

A questo punto scrivete il vostro file nell'editor e quando avete
finito procedete da Sintassi->Converti ad HTML

Non so ancora se è possibile fare la stessa cosa con il vim classico
(quello da console).
Ne sapete qualcosa?

Aggiornamento: Si è possibile farlo anche con il vim da console usando il comando :TO
Ringrazio l'anonimo che lo ha suggerito in un commento a questo post

Parametri script shell

Come si gestiscono le opzioni passate ad uno script shell?
Be prima di tutto distinguiamo tra opzioni senza parametro
e opzioni con parametro.
Esempio:

opzioni senza parametro

./script -a -b

opzioni con parametro

./script -c ciao -d ok

Un metodo per processare queste opzioni è il seguente:

#! /bin/sh

A=false
B=false
C=""
D=""
while true; do
  case "$1" in
  -a)
          A=true
          shift
          ;;
  -b)
          B=true
          shift
          ;;
  -c)
          C=$2
          shift 2
          ;;
  -d)
          D=$2
          shift 2
          ;;

  *)
          break
          ;;
  esac
done

In questo caso se richiamiamo ad esempio lo script in
questo modo:

./script -a -c prova

avremo che la variabile A sarà true B sarà false C prova e D la stringa
vuota.

Bridge di rete

Mi è capitata la seguente situazione:

1. 2 desktop con una scheda di rete ethernet ciascuno che chiameremo
   desk1 e desk2
   
2. 1 desktop con 2 schede di rete rispettivamnete desk3.
   

I pc devono essere tutti e tre collegati in rete. Non avevo
a disposizione un hub ma solo un cavo incrociato.

Soluzione

E' possibile usare un bridge di rete.
Colleghiamo il desk1 e desk2 a desk3 con la connessione ethernet.
A questo punto la situazione è la seguente:

   +--------------------+
   |                    |
   |       desk1        |
   |                    |
   +--------------------+
            | eth0
            |
            |
            | eth0
   +--------------------+
   |                    |
   |       desk3        |
   |                    |
   +--------------------+
            | eth1
            |
            |
            | eth0
   +--------------------+
   |                    |
   |       desk2        |
   |                    |
   +--------------------+

Non ci resta che creare il bridge ed assegnare gli indirizzi ip.
Prima di procedere verificate di avere installato il pacchetto
bridge-utils.

Da eseguire su desk3

creo l'interfaccia del bridge
sudo brctl addbr br0

aggiungo al bridge le due interfacce di rete
sudo brctl addif br0 eth0
sudo brctl addif br0 eth1

azzero gli ip delle interfacce del bridge
sudo ifconfig eth0 down
sudo ifconfig eth1 down
sudo ifconfig eth0 0.0.0.0 up
sudo ifconfig eth1 0.0.0.0 up

assegno un indirizzo ip all'interfaccia del bridge
sudo ifconfig br0 192.168.60.1

Il bridge ora è impostato è dovrebbe essere funzionante.
Naturalmente potete utilizzare un altro indirizzo ip per il vostro
bridge ;)
Non ci rimane che assegnare un indirizzo ip ai pc desk1 e lap2.

Da eseguire su desk1

sudo ifconfig eth0 192.168.60.10

Ora desk1 è ok. Rimane da impostare desk2:

Da eseguire su desk2

sudo ifconfig eth0 192.168.60.20

A questo punto dovrebbe essere possibile pingare uno dei pc
da qualsiasi altro :)

Le novità di upstart

Come saprete la nuova ubuntu edgy eft non utilizza più il vecchio
modello di avvio del sistema ma il nuovo upstart.
Upstart è un modello giovane basato sugli eventi, dinamico, adatto
alle esigenze di un desktop moderno.
Per ora in edgy l'unico vantaggio che ho notato derivato da upsart
è il fatto che il sistema si avvia più velocemente rispetto a prima.
Per il resto upstart utilizza fortemente la compatibilità con
il vecchio system-v.
Infatti quando il computer si avvia viene generato un
evento "startup". Questo evento fa scattare il gestore che si
trova in /etc/event.d/rcS il quale richiama i vecchi scripts in /etc/init.d/
Non esiste più il vecchio inittab. Se avete aggiornato da dapper
lo ritroverete ancora in /etc ma potete tranquillamente rimuoverlo.
Non mi sembra d'altro canto che ci sia un modo semplice
di impostare il runlevel di default se non editando manualmente
lo script /etc/event.d/rc-default

Purtroppo per ora la documentazione è ancora molto scarsa
e l'integrazione nel sistema allo stato primordiale, però upstart
promette bene. Credo che vedremo qualcosa di più interessante
nella prossima Feisty Fown :)

Il comando watch

Ho scoperto un comando che potrebbe tornare utile. Ogni tanto
capita che girando tra i forum o semplicemente dando un'occhiata
alle directory bin ci si accorge di un comando a noi sconosciuto.
watch non fa altro che eseguire il comando passatogli come
parametro periodicamente, con un periodo impostabile.

Può essere utile ad esempio per i programmi che fanno lo scan
di qualcosa. Ad esempio il comando

iwlist eth1 scan

che da come risultato le reti wireless a disposizione con relativa
potenza del segnale. eth1 naturalmente è una scheda wireless.


E' molto comodo usare watch con questo comando:

watch iwlist eth1 scan

il quale fa lo scanning periodicamente ogni 2 secondi di default.
Volendo cambiare il periodo basta aggiungere il parametro -n.
Ad esempio:

watch -n 1 iwlist eth1 scan

fa lo scanning ogni secondo.

Un semplice port scanner

In questo post vedremo come costruire un semplice port scanner.

Cos'è un port scanner?

E' un programmino che
controlla se ci sono delle porte aperte su un certo indirizzo ip
e se si le riporta come tali.

A cosa potrebbe servirmi un port scanner?

Ad esempio potrebbe essere un metodo veloce per scoprire
quali porte sono aperte sul nostro pc ;)

In genere una porta è associata ad un servizio e solitamente i servizi
comuni hanno delle porte standard.
Ad esempio apache porta 80, ssh porta 22 etc.
Ma come si fa per vedere se una porta è aperta?
Semplicemente si può tentare di stabilire una connessione, se si
ha successo la porta è aperta.
Per stabilire una connessione in pratica apriamo un socket tcp
su una certa porta e proviamo a conneterci.
Un numero soltanto potrebbe dirci poco o niente, quindi cerchiamo
di associare un nome di servizio al numero. Per farlo su linux ci viene
incontro il file /etc/services il quale associa ad un numero di porta
un nome di servizio. Quindi non appena riusciamo a stabilire una
connessione, andiamo a ricercare su /etc/services per vedere a
quale servizio corrisponde. Se non troviamo niente vuol dire che non
si tratta di una porta standard.
A questo punto non resta che dare uno sguardo al codice che
troverete linkato in basso a destra.

Download

Ancora perplessità su sudo

Nel post precedente ho scritto di un dubbio sulla ragionevolezza della
scelta di sudo su Ubuntu e della impossibilità di loggarsi come root.
Il dubbio diventa più grande perché spunta fuori un altro problema.
Immaginiamo la configurazione seguente (che è poi la stessa
dell'altro post):

1. una installazione di ubuntu server su una macchina che chiameremo ubuntu-server
2. una installazione di ubuntu desktop su un
   altra macchina che chiameremo ubuntu-desktop

Vogliamo amministrare il nostro sever in remoto (per necessità
ad esempio). Sul server abbiamo alcuni files leggibili solo dall'utente
root (per motivi di sicurezza ad esempio) ma abbiamo necessità
di trasferirli sulla nostra macchina desktop per un motivo qualsiasi.

Bene! Uso scp.

Non posso! Perché dovrei dare questo comando:

scp root@ubuntu-server:nomefiledacopiare \\
                  percorso_su_ubuntu_desktop

il quale mi richiederebbe la password di root che non esiste! Anche
se io sono l'amministratore scp non sa che deve usare sudo!
Ora le soluzioni ci sarebbero comunque ma sono "sporche"!
Non sarebbe forse più ragionevole utilizzare sudo per
l'amminatrazione del desktop e un normale account di root
per il server?
Si lo so che è possibile attivare l'account di root su una installazione
ubuntu ma non sarebbe meglio averlo di default su una installazione
server?

ubuntu come server?

Quando tempo fa iniziai ad usare ubuntu, rimasi un po perplesso
della scelta di avere l'account di root disabilitato di default ma con
il passare del tempo mi sono abituato all'idea e l'ho trovata persino
ragionevole e comoda. Tutto fino a ieri quando mi è sorto un dubbio.
Chi ha letto i posts precedenti si sarà accorto che in questi giorni
sto smanettanto su vmware e ieri ho intallato la versione server di
edgy su una macchina virtuale. Configuro la rete ed installo un
server ssh. Quindi passo all'host e mi loggo sulla macchina virtuale.
Divento root con sudo su e mi si accende una lampadina in testa:
e se io creo il file /etc/nologin e perdo per un motivo qualsiasi la
connessione o dimentico di eliminarlo prima di sloggarmi?
Per chi non lo sapesse, creare il file nologin in etc serve per impedire
a chiunque se non root di loggarsi e lo si usa per svolgere compiti
amministrativi. Se non si ha accesso fisico al server non c'è modo
di riparare al guaio che io sappia. Inoltre, pur avendo l'accesso fisico,
non si può nemmeno fare un reboot o uno shutdown ma bisogna
spegnere in modo crudo.

Sbaglio qualcosa io o il dilemma esiste?

vmware player e console virtuali

Su linux in genere premendo la combinazione di tasti ctrl+alt+fx
dove fx è uno dei tasti funzione ( in ubuntu da 1 a 6 per le console
testuali ed f7 per X) si passa alle console virtuali o all'X server.
Se proviamo a fare lo stesso in una virtual machine vmware dove
vi è installato linux non funziona, perchè il nostro sitema "ospitante"
cattura la combinazione di tasti e passa ad una delle sue console
virtuali.
Per ottenere l'effetto voluto è necessario usare la combinazione
ctrl+alt+spazio+fx mentre la finestra del sistema dentro vmware
ha il focus

vmware player: crearsi le proprie virtual machine

Tempo fa è stato rilasciato gratuaitamente vmware player, un tool
che permette di far girare le virtual machines create con vmware.
Il programma è pacchettizzato per ubuntu edgy ed è scaricabile
direttamente da synaptic o con apt-get (il pacchetto si chiama
vmware-player).
Sul sito di vmware è possibilie scaricare delle virtual machines
già configurate è pronte da far girare con il player.
La cosa bella è che è possibile crearsi le proprie virtual machines
modificandone una esistente. Per una guida su come fare date
uno sguardo qui e qui. In sintesi non si fa altro che editare il file
con estensione vmx (semplice file di testo) che rappresenta
la configurazione della virtual machine per aggiungere o
rimuovere hardware dalla macchina virtuale.
L'unico problema che rimane da risolvere è come creare
le immagini dei dischi virtuali (se ad esempio ne vogliamo una più
grande o più piccola di quella inclusa nella virtual machine che
abbiamo scaricato). Nel secondo link che ho proposto
ci sono delle immagini già pronte da scaricare di dischi vuoti
(compresse occupano solo qualche KB)

Sperimentate gente, sperimentate :)

Convertire file mp3 in wave

AGGIORNAMENTO: qui ho postato un altro metodo per fare le conversioni.

Avete avuto anche voi l'esigenza di convertire files da mp3 a wave da
GNU/linux? Beh io si è ho notato che in Ubuntu non c'è un metodo
semplice per farlo. Credo che in realtà si possa fare con editor audio
come Audacity ma in ogni modo è poco comodo, e se i files da
convertire sono più di uno è ancora più scomodo. Per quanto ne
so quindi non esiste una interfaccia grafica che ci permetta di convertire,
ad esempio una intera di directory di mp3 in wav.
Non ho trovato nemmeno una utilità che mi permettesse di farlo da
console (probabilmente non ho approfondito molto la ricerca!).
Comunque un metodo non troppo difficile per farlo è utilizzare
le utilità messe a disposizione da gstreamer ed in particolare
l'utilità gst-launch che ci permette di costruire una pipeline gstreamer
per elaborare dati audio o video.
In Ubuntu Dapper per convertire un singolo file si può utilizzare il
comando:

gst-launch filesrc location=nomefile.mp3 ! mad ! wavenc ! \\
filesink location=nomefile.wav

Il comando è una unica riga. Qui viene spezzato su due per comodità
di scrittura. Per eseguirlo correttamente eliminate anche \\
Su Ubuntu Edgy Eft invece è leggermente diverso:

gst-launch-0.10 filesrc location=nomefile.mp3 ! mad ! \\
audioconvert ! wavenc ! filesink location=nomefile.wav

Naturalmente è scomodo scrivere questa lunga riga solo per
convertire un unico file. Sarebbe molto più comodo qualcosa
del tipo:

mp32wav nomefile.mp3

Che converte automaticamente il file nomefile.mp3 in nomefile.wav
Ottenere ciò in realtà è molto semplice. Basta scrivere uno script shell
minimale in questo modo:

#! /bin/sh

for file in "$@"; do
filename=`echo $file | cut -d. -f1`
# converto l'estensione del file in caratteri
# minuscoli
ext=`echo $file | cut -d. -f2 | tr A-Z a-z`
if [ "$ext" = "mp3" ]; then
 echo "$file => $filename.wav"
 gst-launch-0.10 filesrc location="$file" ! \\
        mad ! audioconvert ! wavenc ! filesink \\
        location="$filename.wav" >/dev/null 2>&1
fi
done

Anche qui il comando gst-launch-0.10 è spezzato ma va messo su
una sola riga. Lo script è per Ubuntu Edgy Eft, per la Dapper basta
adattare la riga con il comando gst-launch visto prima.
Ora non ci resta che copiare lo script in un file che chiameremo
ad esempio mp32wav e dargli i permessi di esecuzione con

chmod +x mp32wav

;)

Ubuntu Edgy Eft

Ieri è uscita la versione definitiva di ubuntu edgy eft. Io la uso già dalla
beta e devo dire che nonostante i pochi mesi (solo quattro) dalla
precedente release dapper, i cambiamenti sono apprezzabili.
Primo fra tutti l'introduzione del nuovo sistema upstart, che riduce
notevolmente il tempo necessario all'avvio del sistema e rinnova
l'ormai vecchio sysvinit con un nuovo modello basato ad eventi.
Direttamente visibili dall'utente ci sono la nuova schermata di avvio
con un look molto più moderno e gradevole, tomboy una applet per il
pannello di gnome per prendere appunti (molto utile, dopo che ci si
abitua ad usarla non se ne può più fare a meno) e naturalmente
i vari aggiornamenti alle ultime versioni dei software.

Purtroppo però non tutto è positivo! :(
Fino ad un giorno prima dell'uscita ufficiale il gestore degli
aggiornamenti faceva i capricci aggiornando le fonti dai repository
ma non permettendo di effettuare l'aggiornamento vero e proprio.
Oggi ancora non ho avuto modo di verificare se il problema è stato
risolto o meno, in quanto, probabilmente (voglio sperare) a causa
di intasamento della rete causato dalla release, si verificano errori
durante l'aggiornamento delle fonti anche da synaptic.
Altro punto poco gradevole è il fatto che firefox ogni tanto va in crash!

Penso sarebbe stato meglio ritardarne l'uscita di qualche settimana
ed evitare questi piccoli ma fastidiosi problemucci.

Immaginate un nuovo utente che si convince finalmente a passare
ad Ubuntu perchè ne ha sentito parlare molto positivamente.
La installa e si accorge che il sistema di aggiornamenti non va,
firefox va in crash etc... iniziano a venirgli i primi dubbi...

Comunque spero che risolveranno presto questi piccolo problemi
e che per la prossima uscita si prendano il tempo necessario per
far si che non si verifichino nuovamente.

Aggiornamento: purtroppo devo confermare che il problema
sull'update manager persiste anche oggi :(

check su partizioni all'avvio

Ubuntu edgy di default fa il check del file system dopo 30
volte che questo viene montato.
Ma da dove viene questo numero è come si fa ad impostarlo?

Innanzi tutto per sapere ogni quanto avviene il controllo,
si usa il comando:

sudo dumpe2fs /dev/XXXX | grep Maximum

dove /dev/XXXX va sostituito con la partizione
da controllare (ad esempio /dev/hda6).
E' possibile modificare questo valore con il comando
tune2fs.

sudo tune2fs -c max-mount-counts /dev/XXXX

max-mount-counts rappresenta il numero di montaggi
dopo il quale vogliamo che venga eseguito automaticamente
il controllo.

Se impostiamo questo valore a zero il file system non verrà mai
controllato. Non è consigliabile utilizzare questo valore sulle
partizioni di sistema!

Giochi per linux

Chi ha detto che per linux non esistono bei giochi?

Dopo aver risolto il problema dell'accelerazione 3d e
della rete wireless ad-hoc con ubuntu ieri sera ho installato nexuiz.
Su ubuntu l'installazione è semplicissima: si può usare synaptic
o ancora più semplicemente da Applicazioni->Aggiungi/Rimuovi
scegliete la categoria giochi e trovate nexuiz.

Poi dal sito ufficiale ho scaricato la versione per windows
(viva la portabilità) per gli amici che non hanno
ancora visto la luce :)

Mouse e tastiera in mano... si parte.
Il gioco è uno sparatutto molto simile a quake 3 arena
ma migliore sotto molti punti di vista:

1. le arene di nexuiz sono mooolto più belle di quelle di quake
2. è totalmente gratuito e sotto gpl. Per quake 3 arena serve il cd di quake
3. con quake utilizzando la rete wireless spesso riscontravo problemi di perdita della connessione, con neuxiz invece tutto liscio :)
4. supporta la risoluzione 1280x800, quella nativa del mio laptop, quake no e quindi si è costretti ad utilizzarne una più bassa, il che implica schermo sfuocato con conseguente affaticamento della vista

Non ho ancora provato le altre modalità di gioco,
ma in quella di default si è tutti contro tutti in un'arena
dove ogni personaggio è comandato da un utente (più
si è e meglio è) Ogni volta che, spinti da un insana follia
omicida, si uccide un avversario, si guadagna un punto.
Si va avanti così per 15 minuti. Allo scadere del tempo,
chi ha totalizzato più punti vince la battaglia sull'arena
e si passa a quella successiva. E uno dei giochi più
divertenti da giocare in rete tra quelli ai quali ho giocato.

Happy gaming!

Reti wireless Ad-Hoc (da computer a computer)

Supponiamo di voler creare una rete wireless tra due o più

pc senza un access point in Ubuntu Edgy Eft (vale anche per Dapper).
Avendo installato Network-Manager mi aspetterei di poterlo
fare cliccando sull'icona sul pannello di gnome e selezionando
Crea nuova rete wireless ma purtroppo almeno nel mio caso
la procedura sembra non andare a buon fine.

Spulciando tra i manuali delle wireless utilities ho trovato il modo
di procedere manualmente.

Allora prima di ogni altra cosa bisogna impostare la nostra
schedadi rete wireless in modalità ad-hoc (la modalità in
cui si trova all'avvio, di solito è managed che serve per
connettersi ad un access point)

Nei comandi che seguono eth1 va sostituito con la vostra
scheda di rete wireless. Se non sapete qual'è, lanciate iwconfig
senza opzioni, sarà quella con le estensioni wireless ;)

Impostiamo la scheda in modalità ad-hoc

sudo iwconfig eth1 mode ad-hoc

A questo punto impostiamo il nome della rete wireless
Se la rete la state creando voi, potete sceglierne uno a vostro
piacimento. Per impostarlo

sudo iwconfig eth1 essid nome-scelto-da-me

se vogliamo un po di sicurezza in più (consigliato vivamente)
possiamo abilitare la crittografia sul traffico di rete in questo modo:

sudo iwconfig eth1 key on
sudo iwconfig eth1 key s:0123456789ABC

Il secondo comando assegna una password in ascii.
La password è ciò che segue s:
Deve essere di 13 caratteri. Per ulteriori opzioni si rimanda
al manuale di iwconfig.

Nel mio caso ho riscontrato problemi se non assegnavo anche un
canale wireless quindi

sudo iwconfig eth1 channel 1

A questo punto la rete dovrebbe essere attiva e funzionante.
Non rimane che assegnare un ip alla scheda di rete

sudo ifconfig eth1 192.168.0.1 netmask 255.255.255.0 up

Problemi con i driver ati

Se anche voi come me avete avuto problemi con il 3d
su Ubuntu Edgy Eft questa guida potrebbe fare al caso vostro

Nel mio caso il modulo veniva caricato nel kernel e X era
configurato correttamente per utilizzare il driver fglrx,
ma nonostante ciò non riuscivo ad avere l'accelerazione 3d attiva.

Seguendo il tutorial ho aggiunto alla fine del file xorg.conf le seguenti righe:

Section "Extensions"
Option "Composite" "Disable"
EndSection

ed ho risolto il problema

P.S. La mia scheda è una ATI Mobility radeon 9700

Flash player 9 beta

Finalmente è possibile scaricare una prima beta (probabilmente non ufficiale) del flash player in versione 9 per linux da qui.
Alcuni siti purtroppo con la 7 non ne vogliono proprio sapere di funzionare.
La sto usando da appena due giorni e non sembra avere grossi problemi

Per chi non lo sapesse il progetto gnu sta tentando di implementare una versione open del flash player: gnash. Io non l'ho mai testata e quindi non posso esprimere giudizi comunque come si può leggere dal sito ufficiale è ancora in fase di sviluppo intensivo ed è per ora in grado di riprodurre la maggior parte dei filmati flash versione 7 quindi mi sa che ancora per un bel po dovremmo affidarci alla adobe per poter navigare su alcuni siti.

Nuovo Blog

Cos'è linubuntu? No non è una nuova ditribuzione linux basata su ubuntu.
Sono un appassionato di linux ed in particolare di ubuntulinux.
In questo blog troverete piccoli tutorial, soluzioni a piccoli problemi che ho incontrato durante l'utilizzo di questa distribuzione e di linux in generale.