Tempo fa mi sono accorto che il mio server SSH ci metteva un po a richiedermi la password, e dopo vari tentativi (iptables, pam, …) ho scoperto finalmente cosa il realtà lo “rallentava”…. i DNS…

In pratica, di default, per ogni richiesta di accesso, il demone SSHD controlla se l’hostname richiedente corrisponda realmente al suo IP address… questa gestione viene regolata dal parametro di configurazione UseDNS presente in /etc/ssh/sshd_config del server.
Per disabilitare questa funzionalità:
sudo vi /etc/ssh/sshd_config
aggiungere (se non è già presente)
UseDNS no
e quindi, per riavviare il demone:
sudo /etc/init.d/ssh restart

Visto il “successo” del post Class Browser per gedit ecco come poter utilizzare la stessa funzionalità con gVim


Per prima cosa occorre (come visto nel precedente post) installare ctags
sudo apt-get install exuberant-ctags
ed il pacchetto vim-full
sudo apt-get install vim-full
Quindi scaricare il pacchetto taglist di Vim
wget http://vim.sourceforge.net/scripts/download_script.php?src_id=7701
ed installarlo
mkdir $HOME/.vim
cd $HOME/.vim
unzip /path/dove/hai/scaricato/il/file/taglist_45.zip
Ora non resta altro che modificare il file $HOME/.vimrc (o $HOME/.gvimrc) con l’editor che preferite (gVim ovviamente ) aggiungendo alla fine:
nnoremap <silent> <F8> :Tlist<CR>
così premendo F8 la TagList compare/scompare…
Buon divertimento

Per maggiori informazioni vi consiglio di fare un giro su http://vim-taglist.sourceforge.net/

Ce ne sono molti di software che permettono di fare il backup di cartelle/files, con bellissime interfacce grafiche ma… io preferisco il vecchio metodo… rsync, ssh ed il gioco è fatto

Per prima cosa sul Server occorre installare un server SSH, inutile parlare qui di questo aspetto e per questo vi rimando alla pagina del Wiki, e vi consiglio di seguire soprattutto questo paragrafo
Detto questo… ecco il comando che lancio io per fare il backup della mia home
rsync -vaz -e ssh $HOME/ paper0k@serverone:/Backup/paper0k/
dove paper0k@serverone è rispettivamente l’account remoto (paper0k) sul server remoto (serverone) e /Backup/paper0k è la cartella remota dove scaricare la mia home ($HOME)
Al primo avvio ovviamente ci metterà un pochino, perchè dovrà allineare le due cartelle (locale e remota) ai successivi lanci però, verranno allineati solo i files nuovi/modificati
Se necessitiamo inoltre di cancellare i files sul server non più presenti nella home, allora dobbiamo usare l’opzione --delete preferibilmente associata alla --max-delete=NUM per cancellare al massimo NUM files dalla cartella di destinazione e per ulteriori dettagli vi consiglio di leggere la manpage
man rsync
Certo, il server, dovrà avere abbastanza spazio

In questi giorni mi sono installato un “serverino”, e per condividere i files tra i vari computer, ho usato NFS.
Ma sul “serverino” ovviamente c’era iptables, in configurazione firewall, e visto che era la terza volta che mi cimentavo nella configurazione delle iptables per poter consentire l’accesso NFS (dimenticandomi ogni volta i passi seguiti, o se preferite le porte lasciate “aperte” sul firewall), ho deciso scriverle e condividerle con voi.
Magari così la prossima volta non ci perdo, nuovamente, troppo tempo!
for P in $(rpcinfo -p|awk '{ if (NR>1) print $4; }'|sort -u)
do
echo “NFS port $P”
$IPTABLES -A INPUT -p udp -i $IFEXT –dport $P -j LOG –log-level info –log-prefix “#NFS-U-${P}#”
$IPTABLES -A INPUT -p udp -i $IFEXT –dport $P -j ACCEPT
$IPTABLES -A INPUT -p tcp -i $IFEXT –dport $P -j LOG –log-level info –log-prefix “#NFS-T-${P}#”
$IPTABLES -A INPUT -p tcp -i $IFEXT –dport $P -j ACCEPT
done

nella mia configurazione, IPTABLES è uguale a “/sbin/iptables” e IFEXT a “eth0″

Che dire….. Grazie a tutti!!!

Come sapete (???) ho un Acer Aspire 5634WLMi con Ubuntu Feisty 64bit e Compiz, e la sospensione non ha mai funzionato, ma era un argomento che poco mi interessava, quindi ho lasciato correre e mi sono detto “quando avrò un po di tempo lo sistemo”… ho avuto quel “po di tempo” a disposizione per sistemarlo!

Per gli utenti di Ubuntu 7.10 Gutsy
Non occorre seguire questa procedura, il sistema (almeno sul mio pc) gestisce senza problemi la sospensione

La prima cosa che ho fatto è stata modificare il file /etc/X11/xorg.conf da così

Section "Device"
    Identifier     "nVidia Corporation G72M [Quadro NVS 110M/GeForce Go 7300]"
    Driver         "nvidia"
EndSection

a così

Section "Device"
    Identifier     "nVidia Corporation G72M [Quadro NVS 110M/GeForce Go 7300]"
    Driver         "nvidia"
    Option         "NvAGP" "1"
    Option         "AddARGBVisuals" "True"
    Option         "AddARGBGLXVisuals" "True"
EndSection

quindi ho modificato il file /etc/default/acpi-support portando queste opzioni

POST_VIDEO=true
SAVE_VBE_STATE=true

in false, cioè:

POST_VIDEO=false
SAVE_VBE_STATE=false

Infine, nelle opzioni di Compiz, ho disabilitato l’opzione “Sync to VBlank” e dopo aver riavviato il PC……. si è finalmente addormentato!

Attenzione

1. Ovviamente non è detto che quello sopra riportato vada bene per tutti!
2. Prima di fare delle prove di sospensione salvate/chiudete i files non salvati e le applicazioni critiche, il sistema non è detto che riparta…
3. Se l’interfaccia grafica non riparte, provate (prima di spegnere il PC) a riavviarla (Ctrl-Alt-Backspace) o andare in modalità testo (Ctr-Alt-F1) per riavviare il PC in maniera sicura
4. Alcuni hanno avuto problemi con la tastiera (io per fortuna no…) dopo il ripristino, in quel caso vedete questo link ( http://sittisal.wordpress.com/2007/05/17/ubuntu-feisty-su-hp-compaq-nx7400/ ), forse potrà aiutarvi

Questa vuole essere una piccola introduzione allo sviluppo in C++ utilizzando Glade3, per la creazione dell’interfaccia utente, e le librerie Gtk

Per questo programmino, ci faremo aiutare dagli autotools, quindi creiamo una directory, ad esempio “ex1″:
mkdir ex1
ed al suo interno creiamo un file configure.ac come il seguente:
AC_INIT(src/main.cc)
AM_INIT_AUTOMAKE(ex1,0.1)
AC_CONFIG_HEADER(config.h)
AC_PROG_CC
AC_PROG_CXX
AC_PROG_INSTALL
AC_PROG_LIBTOOL
PKG_CHECK_MODULES([GTKMM], [gtkmm-2.4 >= 2.8.0])
PKG_CHECK_MODULES([GLADEMM], [libglademm-2.4])
AC_SUBST(GTKMM_CFLAGS)
AC_SUBST(GTKMM_LIBS)
AC_SUBST(GLADEMM_CFLAGS)
AC_SUBST(GLADEMM_LIBS)
AC_OUTPUT(Makefile src/Makefile)

sempre in questa cartella, creiamo il file Makefile.am, al cui interno mettiamo:
SUBDIRS = src
così da avere il codice separato dagli altri files e quindi creiamola:
mkdir src
cd src
e dentro inseriamo il file Makefile.am
bin_PROGRAMS=ex1
ex1_SOURCES=main.cc wmain.h wmain.cc
EXTRA_DIST = wmain.glade
INCLUDES = $(GTKMM_CFLAGS) $(GLADEMM_CFLAGS)
LIBS = $(GTKMM_LIBS) $(GLADEMM_LIBS)

Siamo quindi pronti a scrivere il codice, iniziamo dal main.cc:

#include <iostream>
#include "wmain.h"

int main(int argc, char *argv[])
{
    Gtk::Main kit(argc, argv);

        Glib::RefPtr<Gnome::Glade::Xml> refXml;
        try    {
                refXml = Gnome::Glade::Xml::create("wmain.glade");
        }
        catch(const Gnome::Glade::XmlError& ex)        {
                std::cerr << ex.what() << std::endl;
                return 1;
        }

        wMain* W = 0;
        refXml->get_widget_derived("wMain", W);
        if(W)  {
                kit.run(*W);
        }

        delete W;

    return 0;
}

questo provvederà a caricare il file .glade (vediamo dopo come crearlo), estrarre il widget wMain, “associarlo” ad una nostra classe ed a lanciare l’applicazione
Vediamo come creare la nostra classe, iniziamo dall’header wmain.h:

#ifndef WMAIN_H
#define WMAIN_H

#include <gtkmm.h>
#include <gtkmm/button.h>
#include <libglademm.h>
#include <iostream>

using namespace std;

class wMain : public Gtk::Window {
public:
        wMain(BaseObjectType* cobject, const Glib::RefPtr<Gnome::Glade::Xml>& refGlade);
        virtual ~wMain();
        virtual void btnEsci();
        virtual void btnOk();
private:
        Gtk::Entry *txtNome;
};

#endif

Quindi passiamo al wmain.cc:

#include "wmain.h"

wMain::wMain(BaseObjectType* cobject, const Glib::RefPtr<Gnome::Glade::Xml>& refGlade) : Gtk::Window(cobject) {
        Gtk::Button *btn;

        /** btnEsci */
        refGlade->get_widget("btnEsci", btn);
        if (btn) {
                btn->signal_clicked().connect( sigc::mem_fun(*this, &wMain::btnEsci) );
        } else {
                cerr << "btnEsci non trovato!" << endl;
        }

        /** btnOk */
        refGlade->get_widget("btnOk", btn);
        if (btn) {
                btn->signal_clicked().connect( sigc::mem_fun(*this, &wMain::btnOk) );
        } else {
                cerr << "btnOk non trovato!" << endl;
        }

        refGlade->get_widget("txtNome", txtNome);

}

wMain::~wMain() {
}

void wMain::btnEsci() {
        cout << "Esci" << endl;
        Gtk::Main::instance()->quit();
}

void wMain::btnOk() {
        Glib::ustring txt;
        txt="Testo ["+txtNome->get_text()+"]";
        Gtk::MessageDialog dlg(*this, txt, false, Gtk::MESSAGE_INFO,
                               Gtk::BUTTONS_OK, true);
        dlg.run();
}

praticamente abbiamo definito la classe wMain derivata dalla Gtk::Window, nel costruttore abbiamo quindi “cercato” i due tasti “btnEsci” e “btnOk”, collegando l’evento “clicked” ai nostri metodi wMain::btnEsci e wMain::btnOk, e abbiamo memorizzato il puntatore alla GtkEntry txtNome.
Nel metodo wMain::btnOk, andiamo ad estrarre il valore inserito nella entry e visualizzarlo tramite un message box, mentre in wMain::btnEsci lanciamo il Gtk::Main::instance()->quit() che termina l’applicazione.
Ora possiamo creare l’interfaccia grafica usando Glade3, quindi da terminale e dentro la cartella src lanciamo:
glade-3
Quello che ci comparirà sarà:

dalla tavolozza (dock a sinistra), premiamo il tastino “Finestra”

sempre dalla tavolozza, selezioniamo il contenitore “Casella verticale” ed impostamo il numero di elementi a 2

per ogni elemento (il box creato) inseriamo una “Casella orizzontale” di 2 elementi

Nel box in alto a sinistra inseriamo una GtkLabel selezionando dalla tavolozza, nel riquadro “Controlli e visualizzazione” il tastino “Etichetta”
Nel box in alto a destra invece inseriamo una GtkEntry (tastino “Entrata testo” sempre in “Controlli e visualizzazione”)
Nei box sotto inseriamo due GtkButton (tastino “Pulsante”)

impostando nelle proprietà la tipologia come “Stock” (vedi barra evidenziata)

la prima con “Pulsante stock” in “Applica”, l’altra con “Chiudi”

Ora non resta che assegnare i nomi come nella seguente figura

Salviamo quindi il file nella cartella “src” col nome “wmain.glade” e, tornando nella cartella principale del progetto diamo i comandi:
touch NEWS README AUTHORS ChangeLog
touch stamp-h
aclocal
autoheader
libtoolize -f
automake -ac --foreign
autoconf

Se tutto è andato bene, diamo un
./configure
make
e per lanciare il nostro programmino
cd src
./ex1
Buon divertimento!

Pacchetti da installare
Ci sono una serie di pacchetti che occorre avere prima di procedere con lo sviluppo:
sudo apt-get install build-essential automake1.9 pkg-config libglademm-2.4-dev libgtkmm-2.4-dev
potrebbero mancarne alcuni, in quel caso fatemi sapere cosa mi sono dimenticato

Link utili
Sicuramente vi saranno di aiuto
http://www.gtkmm.org/docs/gtkmm-2.4/docs/tutorial/html/index.html
http://sourceware.org/autobook/autobook/autobook_toc.html

Quante volte vi siete trovati davanti ad una funzione domandandovi: “ma dov’è definita? cosa fa esattamente?”
Non vi siete posti questa domanda? Allora questo post non è per voi!

Lo script che vi presento oggi, serve proprio a questo, cercare la definizione di una funzione e visualizzarne l’implementazione
Per prima cosa occorre installare il pacchetto exuberant-ctags, quindi come di consueto:
sudo apt-get install exuberant-ctags
quindi aprite l’editor che preferite ed inserite questo codice:
#! /bin/bash
TMPFILE=/tmp/$$
ctags -R -x 2>/dev/null | grep "^${1} *function " > $TMPFILE
if [ ! -s $TMPFILE ]
then
echo "Funzione ${1} non trovata"
exit 1
fi
SZ=$(wc -l $TMPFILE|cut -d " " -f 1)
if [ ! ${SZ} -eq 1 ]
then
echo "Funzione rilevata più volte"
cat $TMPFILE
else
FILE=$(cat $TMPFILE|awk ‘{ print $4 }‘)
LINE=$(cat $TMPFILE|awk ‘{ print $3 }‘)
echo "Apertura $FILE posizione $LINE …"
vim +${LINE} $FILE
fi
rm -f $TMPFILE


Attenzione! L’apice non viene scritto correttamente nel codice sopra riportato, quindi sostituite ` (apice inverso) con un ‘ (apice normale)

Salviamo il file (ad esempio come cercaFunzione) e impostiamo i permessi necessari:
chmod +x cercaFunzione
Ora per ricercare una funzione (ad esempio myFunction), andiamo nella cartella dei sorgenti e digitiamo:
/path/dello/script/cercaFunzione myFunction
(invece di /path/dello/script/ dovete inserire il path dove avete salvato lo script) automaticamente verrà aperto VIm e sarà posizionato esattamente dove si trova la funzione myFunction

Spesso capita di copiare files da una cartella ad un’altra e dimenticarsi poi di cancellarli, oppure non sapere di aver già quel documento salvato su di un’altra cartella…. ed intanto il disco si riempie…. ecco come faccio io

Utilizzo questo script:

#! /bin/bash

LSTFILE=$(tempfile)
WRKFILE=$(tempfile)
DUPFILE=$(tempfile)

if [ -z "${#}" ]
then
        D="."
else
        D="${1}"
fi

echo "Ricerca in corso su ${D} ..."
find "$D" -type f -exec md5sum {} \; > $LSTFILE 2>/dev/null

echo "Analisi files..."
while read SUM FILE
do
        #echo "Analisi $FILE in corso... [${SUM}]"
        if grep "^${SUM} " $WRKFILE >/dev/null 2>&1
        then
                DUPLICATO=$(grep "^${SUM} " $WRKFILE | cut -d " " -f 2-)
                TIPO=$(file "${FILE}"|cut -d ":" -f 2-)
                echo "Errore $FILE uguale a $DUPLICATO (${TIPO} )"
                echo "${FILE} ${DUPLICATO} ${SUM} (${TIPO} )" >> $DUPFILE
        else
                echo "${SUM} \\"${FILE}\\"" >> $WRKFILE
        fi
done < $LSTFILE

rm -f $LSTFILE $WRKFILE 2>/dev/null
if [ -s $DUPFILE ]
then
        echo "File con i duplicati: $DUPFILE"
else
        rm -f $DUPFILE
fi
echo "Terminato."

basta lanciarlo specificando la cartella da dove iniziare le ricerche, ad esempio:
./filesDuplicati.sh /media/sda1/Multimedia/Foto/
per cercare i files duplicati contenuti nel mio HD USB esterno… ottenendo un output come questo:
Ricerca in corso su /media/sda1/Multimedia/Foto/ ...
Analisi files…
Errore /media/sda1/Multimedia/Foto/test/pippo.jpg uguale a ‘/media/sda1/Multimedia/Foto/test2/P1010244.JPG’ ( JPEG image data, EXIF standard 2.2 )
Errore /media/sda1/Multimedia/Foto/test/pippo paperio.jpg uguale a ‘/media/sda1/Multimedia/test2/Enrico/P1010244.JPG’ ( JPEG image data, EXIF standard 2.2 )
File con i duplicati: /tmp/filepIPI5p
Terminato.

Buona ricarca!

Possibile? Ceeeeeerto!

E’ possibile personalizzando il comportamento della libreria readline, utilizzata di default da bash e da molte applicazioni dal terminale

Per prima cosa, creiamoci il nostro file di configurazione
cp /etc/inputrc .inputrc
quindi usando gedit o l’editor che preferite
gedit .inputrc
andiamo ad aggiungere alla fine queste righe:
"\C-k\C-u": "sudo apt-get update && sudo apt-get upgrade\r"
quindi salviamo ed apriamo un nuovo terminale… tenendo premuto il tasto Control, premiamo k e quindi u… cosa accade? Abbiamo evitato di dover scrivere “sudo apt-get update && sudo apt-get upgrade” a terminale, ha fatto tutto lui per noi!!!
Con \C viene indicato il tasto Control seguito dalla lettera che vogliamo usare, mentre con \r alla fine che deve essere premuto INVIO…
Questa è una base ovviamente, e molto è possibile fare/personalizzare, quindi, buon divertimento!