-+  Associazione
-+  Documenti
-+  Eventi
-+  Community
-+  Blog
-+  Link

Ottobre 2013

Dom Lun Mar Mer Gio Ven Sab
    1 2 3 4 5
6 7 8 9 10 11 12
13 14 15 16 17 18 19
20 21 22 23 24 25 26
27 28 29 30 31    

Cerca






 


« Giugno 2004 | Home | Agosto 2004 »

Italian Code Jam

Qualunque cosa dobbiate fare il 9 Ottobre 2004, annullatela.

Mi spiego immediatamente: in ottobre parte da Venezia la GeekCruise, a bordo della quale, tra gli altri track, ci sarà la Perl Whirl. Il LUG di Ferrara ha avuto la magnifica idea di organizzare un evento dedicato all'Open Source, nei giorni precedenti, sfruttando la presenza in Italia di personaggi di levatura internazionale. All'organizzazione stanno contribuendo ora altri LUG, e i Perl Mongers Italiani.

L'evento si chiama Italian Code Jam, e tra gli speaker vedrà (sedetevi :)) Allison Randal, Dave Cross e Larry Wall. Sì, proprio quel Larry :)

A Ferrara, presso il Dipartimento di Ingegneria, il 9 Ottobre 2004. Ci si vede :)

(Update: volevo presentare un po' in pompa magna la cosa, ma il portatile (l'uscita video, per la precisione) mi ha tradito. Il numero del mio badge è 17, trall'altro, con buona pace di Smullyan)

Inviato da larsen alle 16:09 | Commenti (2)

IPW Day 2

I problemi di rete seguono i Perl Mongers come la nuvoletta di pioggia di Fantozzi (vi dice niente la parola Webbit?). Ad ogni modo, cavo alla mano, il vostro umile narratore è in grado (alla buon'ora delle 15) di riferire come sta procedendo il workshop.

Dopo la nottata brava in giro per Pisa (ottima cena, e dopo cena tutto sommato appagante), ci ritroviamo al mattino per la giornata conclusiva: interessante talk di Michel Rodriguez (di nuovo, questa volta una panoramica sui vari moduli che permettono di gestire file XML); poi Andrea Rota su Bricolage, Filippo Bardelli sul praticissimo modulo di interfacciamento ad OpenOffice, infine Marco Masetti sul framework Extropia per le applicazioni web (da esplorare, compresa l'estensione dello stesso Marco).
Nel momento in cui scrivo Enrico Sorcinelli sta presentando il suo talk su CPAN.

Inviato da larsen alle 15:54 | Commenti (0)

IPW Day 1 - Pisa è piccina

Al grido di "Pisa è piccina!" (ripetuto ad libitum da dakkar) ci siamo trovati domenica sera davanti ad un'insalata di farro con frutti di mare e boccale di birra. Stamattina (dalle 8, alacri come api operaie) abbiamo messo in piedi la poderosa struttura ricettiva del Workshop imbustando badge, preparando borse di gadget e frugando alla disperata nello scatolone delle magliette, consapevoli che la misura giusta è sempre l'ultima che ti capita in mano.

La prima tornata di interventi è stata intensa e divertente, tutto è filato liscio come l'olio (un grazie all'Università e a tutti i Pisa.pm minions per l'ottimo supporto). dakkar ci ha gentilmente introdotti a gioie e dolori dell'Unicode, John McNamara a dolori e gioie di Excel. Dopodiché sono stato richiamato al mio dovere di receptionist: lascio ad altri l'onere di commentare i talk di David e Dmitry.

L'aria è serena, la gente sembra contenta e tutto procede tranquillamente. Per ora è tutto dal vostro umile inviato speciale a Pisa, a risentirci nel pomeriggio.

Inviato da dada alle 15:00 | Commenti (0)

Primi con Perl

Navigando un po' per la rete come di solito faccio la sera per rilassarmi, l'altro giorno mi sono imbattuto in un progetto che ha come scopo la ricerca del numero primo piu' grande mai scoperto. Il progetto conteneva software e numerose informazioni su come fare per scrivere il proprio nome nella storia della matematica! :)

Comunque, incuriosito, ho rispolverato il libro di matematica alla ricerca del significato dei numeri primi e del modo in cui essi si calcolano. Un numero primo e' un numero divisibile soltanto per 1 e per se stesso; ma come si calcola?

Fin'ora nonostante le numerose ricerche e la nostra inarrestabile evoluzione, l'unico metodo sicuro e funzionante e' quello inventato da Eratostene gia' dal 240 ac, il cosiddetto Crivello di Eratostene.

Il metodo consiste nel partire da 2 e togliere via via tutti i suoi multipli, poi passare al numero successivo che e' 3 e fare la stessa cosa, quindi 5 (visto che 4 lo abbiamo scartato) poi 7 ( 6 scartato) poi 11 e cosi' via all'infinito.

Affascinato dal metodo mi sono subito chiesto in che modo poterlo implementare in Perl, e dopo numerose auto-ottimizzazioni, Vi rimetto la mia soluzione:

sub{ $_[0] % $_ ? next : return 1 for @p}->($_) || print $p[$n++]=$_,"\n" for 2..1000

Inviato da LucaS alle 01:59

Verificare l'esistenza di indirizzi e-mail

Sulla mailing list debian-italian è stato chiesto se era possibile verificare l'esistenza degli indirizzi e-mail contenuti in un file, qualcuno ha proposto una soluzione (quella implementata che vedremo in seguito).

Cosa ci serve:

  1. un file contenente gli indirizzi e-mail da verificare (io utilizzerò quello del mio mutt)
  2. un server DNS per ottenere il record MX legato al dominio
  3. una connessione SMTP per lanciare il comando VRFY e
  4. il dominio a cui appartiene il client su cui gira il programma

Gli ultimi tre punti ci fanno subito venire in mente Net::DNS, Net::SMTP e Net::Domain, quindi per prima cosa diamo una veloce sfogliata al perldoc di questi tre moduli. Sono tutti molto semplici da utilizzare, possiamo vedere fin da subito che Net::DNS dispone della funzione mx che fa proprio al caso nostro, Net::SMTP della funzione verify e Net::Domain di hostfqdn. Quindi per iniziare:

#!/usr/bin/perl -w
use strict;
use Net::DNS;
use Net::SMTP;
use Net::Domain qw(hostfqdn);

Per ottenere gli indirizzi e-mail dal file utilizzeremo una regular expression che vedremo sotto.

Assembliamo il tutto

Innanzitutto il formato delle righe del file contenente gli indirizzi è:

alias mattia Mattia Dongili <dongili@supereva.it>

Dobbiamo analizzarlo e costruire una struttura dati comoda per il successivo uso: estrarre il record MX, collegarci e lanciare il comando VRFY su ogni indirizzo dello stesso dominio. La struttura adatta a questo è chiaramente un hash di arrayref dove la chiave dell'hash è il dominio e l'array contiene gli username da verificare; questo ci permette di raggruppare tutti gli indirizzi appartenenti allo stesso dominio ottimizzando poi le connessioni SMTP: con un'unica connessione possiamo lanciare N volte il comando VRFY. Andiamo avanti:

Una piccola utility per analizzare le opzioni da riga comando (si, sono molto pigro...):

use Getopt::Long;

in questo hash salviamo la struttura dati ottenuta dal parsing del file (hash di arrayref):

my %addrs;

dichiariamo la variabile che conterrà il nome del file e un flag che attiva la stampa di informazioni di debug, entrambi ottenuti da riga comando:

my $address_file;     
my $debug = 0; # default disattivato

finalmente l'analisi delle opzioni passate da riga di comando e la verifica della valorizzazione di $address_file. Se qualcosa va storto stampiamo l'help:

if (!GetOptions ("file=s" => \$address_file, "debug" => \$debug) 
    || !$address_file) {
  print <<EOHELP;
usage: $0 -f <file> [-d]
EOHELP
  exit 0;
}

apriamo il file e scorriamolo riga per riga:

open(FP, "<$address_file") || die "$^E ($address_file)";
while (<FP>) {

ora analizziamo la singola riga per estrapolare l'indirizzo e-mail nelle sue due parti di utente@dominio:

   if ( /
          ^                             # Inizio riga
            alias.*?<                   # scartiamo il primo token nel 
                                        # nostro esempio
                                        # 'alias mattia Mattia Dongili <'
            ([a-zA-Z0-9_\.-]+?)         # nome utente dell'indirizzo 
                                        # (salvato in $1),
                                        # nel nostro esempio 'dongili'
            \@                          # chiocciola :)
            ([a-zA-Z0-9\.-]+?\.\w{2,3}) # parte dominio dell'indirizzo 
                                        # (salvato in $2), nel nostro 
                                        # esempio 'supereva.it'
            >                           # scartiamo anche l'ultimo 
                                        # carattere
          $                             # Fine riga
         /x ) {

aggiungiamo il nome utente appena letto all'array corrispondente al suo
dominio:

push( @{ $addrs{$2} }, $1);

se e` fallita l'analisi della riga stampiamo un warning:

   } else {
      warn "wrong line format: $_\n";
    }
  }

non dimentichiamoci la chiusura del file:

 close FP;

ed infine se non abbiamo trovato nessun indirizzo e-mail usciamo

 die "No email address found" unless keys(%addrs);

Una volta costruita la nostra struttura dati procediamo scorrendola per chiave (il dominio) e verifichiamo ogni indirizzo, quindi:

il ciclo principale:

 foreach my $domain (keys(%addrs)) {

facciamo una query al nostro DNS server sul record MX ottenendo l'elenco di MX del dominio in questione in @mxs:

   my $res = Net::DNS::Resolver->new;
    my @mxs = mx($res, $domain);

stampiamo un warning se l'array di MX e` vuoto:

   if (!@mxs) {
      warn "Can't find MX records for $domain ",
            ($res->errorstring ne 'NOERROR' ? $res->errorstring : ""), "\n";
    }

altrimenti colleghiamoci al primo server che ci e` stato indicato dal DNS:

   else {    
      # Inizio sessione SMTP
      print $mxs[0]->exchange,"\n";
      my $smtp = Net::SMTP->new($mxs[0]->exchange,
                                Hello => hostfqdn(),
                                Timeout => 30,
                                Debug   => $debug,
                                );

lanciamo il comando VRFY per ogni indirizzo associato a questo dominio:

     if ($smtp) {
        foreach (@{ $addrs{$domain} }) {
          # VRFY
          if ($smtp->verify("$_\@$domain")) {
            print "$_\@$domain exists\n";
          } else {
            print "Cannot VRFY $_\@$domain\n";
          }
        }
        # Fine sessione SMTP
        $smtp->quit;
      } else {
        print "No SMTP connection for ", $mxs[0]->exchange, "\n";
      }

chiudiamo un po` di parentesi:

   } # fine else
  } # fine freach

Tutto qui.

Conclusioni

E` stato facile no?

Purtroppo però questa soluzione si scontra con lo stato attuale della rete internet che ormai è un covo di spammatori e virus, e dunque i comandi che sono stati utilizzati per verificare gli indirizzi sono in realtà disabilitati sulla maggioranza degli SMTP server. Inoltre alcuni SMTP server ritengono che le troppe VRFY siano un abuso e tendono a disabilitare l'accesso a chi lo fa. Per questo in realtà la verifica degli indirizzi e-mail non si può fare ™.

Credits

Devo ammettere che l'uso di Net::Domain non è venuto in mente a me ma al poliedrico Bronto, grazie anche a Larsen per la revisione e i consigli.

Codice

 #!/usr/bin/perl -w
  use strict;
  use Net::DNS;
  use Net::SMTP;
  use Net::Domain qw(hostfqdn);
  use Getopt::Long;
 my %addrs;          
  my $address_file;     
  my $debug = 0;
 if (!GetOptions ("file=s" => \$address_file, "debug" => \$debug) 
      || !$address_file) {
    print <<EOHELP;
  usage: $0 -f <file> [-d]
  EOHELP
    exit 0;
  }
 open(FP, "<$address_file") || die "$^E ($address_file)";
  while (<FP>) {
   if ( /
          ^                             # Inizio riga
            alias.*?<                   # scartiamo il primo token nel 
                                        # nostro esempio
                                        # 'alias mattia Mattia Dongili <'
            ([a-zA-Z0-9_\.-]+?)         # nome utente dell'indirizzo 
                                        # (salvato in $1),
                                        # nel nostro esempio 'dongili'
            \@                          # chiocciola :)
            ([a-zA-Z0-9\.-]+?\.\w{2,3}) # parte dominio dell'indirizzo 
                                        # (salvato in $2), nel nostro 
                                        # esempio 'supereva.it'
            >                           # scartiamo anche l'ultimo 
                                        # carattere
          $                             # Fine riga
         /x ) {
     push( @{ $addrs{$2} }, $1);
   } else {
      warn "wrong line format: $_\n";
    }
  }
  close FP;
 die "No email address found" unless keys(%addrs);
 foreach my $domain (keys(%addrs)) {
    my $res = Net::DNS::Resolver->new;
    my @mxs = mx($res, $domain);
   if (!@mxs) {
      warn "Can't find MX records for $domain ",
            ($res->errorstring ne 'NOERROR' ? $res->errorstring : ""), "\n";
    }
    else {
     # Inizio sessione SMTP
      print $mxs[0]->exchange,"\n";
      my $smtp = Net::SMTP->new($mxs[0]->exchange,
                                Hello => hostfqdn(),
                                Timeout => 30,
                                Debug   => $debug,
                                );
     if ($smtp) {
        foreach (@{ $addrs{$domain} }) {
          # VRFY
          if ($smtp->verify("$_\@$domain")) {
            print "$_\@$domain exists\n";
          } else {
            print "Cannot VRFY $_\@$domain\n";
          }
       }
        # Fine sessione SMTP
        $smtp->quit;
      } else {
        print "No SMTP connection for ", $mxs[0]->exchange, "\n";
      }
   }
  }

Inviato da mattia alle 18:48 | Commenti (2)

L'Olanda prende posizione sulla legge sul software

Per la prima volta nella storia dell'Europa Unita una nazione converte un suo voto di appoggio in astensione: dato che fino ad ora ci sono stati solo accordi politici e il voto reale sarà possibile solo quando il testo di legge verrà tradotto nelle 20 lingue dell'unione, il Parlamento olandese ha potuto revocare il suo appoggio per il testo del Consiglio dei Ministri sulle direttive per la brevettabilità del software. Sì è venuto così a creare un precedente importante e una presa di coscienza che fa ben sperare.

Il testo della notizia

Inviato da jontk alle 15:52 | Commenti (1)

D:
Progetti e documenti in rilievo
Corso di Perl Progetto pod2it
D:
La ML di Perl.it
mongers@perl.it è la lista ufficiale di Perl Mongers Italia per porre quesiti di tipo tecnico, per rimanere aggiornato su meeting, incontri, manifestazioni e novità su Perl.it.
Iscriviti!
D:
Annunci Google