Introduzione a PERL

E.Mumolomumolo@units.it

Prima parte.Introduzione al linguaggio

Practical Extraction and Report Languageor

Pathological Eclectic Rubbish Lister?

Introduzione a PERL

• Nato per assistere l’utente Unix per le comuni operazioni, troppo pesanti, troppo dipendenti dalla shell ma troppo complesse da codificare in C ...

• Compattezza (sinteticità) e potenza

• Ambiente più naturale: Unix. Integra comandi sed awk grep mail IPC …

• Finalizzato principalmente per elaborare stringhe e file di testo

 • Correntemente molto usato per operazioni di amministrazione di sistema e per

CGI/HTTP

 • Linguaggio Interpretato

• Riferimenti classici:

- Programming PERL, L.Wall. R.L.Schwartz

- Learning PERL, R.L.Schwartz

Istruzioni di base

• Come si presenta uno script PERL (primo.pl)#!/user/bin/perl#esempio inizialeprint “scrivi una stringa terminata da return”;$nome=<STDIN>;print “ciao $nome\n”;

• Esplicitamente: prompt> perl primo.pl

• Simboli:{} rappresenta un blocco di istruzioni# commenti$ precede nomi variabili e elementi scalari di array@ precede nomi di array normali o di raggruppamenti di elementi di

array% precede i nomi di array associativi& precede i nomi delle funzioni<STDIN>, <STDOUT> descrittori di standard input, output

• Redirezione: prompt> primo.pl < filein > fileout

Tipi di dati in PERL• Stringhe – Numeri – Riferimenti - Liste. Non esiste il tipo logico, ma solo condizioni.

Oppure: variabili non dichiarate, stringhe nulle, stringa “0” e il numero 0 Falso

• Tipo definito con l’inizializzazione. Es: $a=“stringa di prova”; $a=‘0xFF’, $a=‘037’

• Numeri : rappresentazione interna solo doppia precisione

• Delimitatori delle stringhe : – accento singolo : tutti i caratteri tranne tranne ‘ e \ (usare ‘\ e \\)– accento doppio : interpolazione e caratteri di controllo

• Caratteri di controllo :\n newline \cC un carattere di controllo (qui: control-C)\r return \\ backslash\t tab \” doppio accento\f linefeed \l il prossimo carattere e’ minuscolo\b backspace \L tutte i prossimi caratteri sono minuscoli\v tab verticale \u il prox carattere e’ maiuscolo\a bell \U tutti I prox caratteri sono maiuscoli\e esc \E termina \L o \U\007 il valore ottale 07 \x7f il valore hex 7f

Operatori• Operatori aritmetici :+ - * / ** % post/pre-decremento, incrementoNB:Calcoli internamente in virgola mobile • Operatori logici  :

– AND (&&) Se il primo e’ falso, non valuta il secondo Es. $a>10&&print “$a maggiore di 10”– OR (||) Se il primo è vero non valuta il secondo. Es. $a>10||print “$a minore di 10”– NOT (!) Inverte il risultato logico– di confronto tra numeri: < <= > >= == !=– di confronto tra stringhe: lt le gt ge eq ne

 • NB : il confronto tra stringhe e’ diverso dal confronto tra numeri • Operatori per stringhe :

– concatenazione: . (es. “aaa”.”bbb” = aaabbb $a . $b)– ripetizione: x (es. ‘a’x3 = aaa $a x $b)– sottostringa substr($a,$n,%m) a partire da n per m caratteri– Indice index($a,$b) posizione del primo carattere di $b

• Casting delle variabili a seconda dell’operatore Esempio: “F” . (“ 43” + 6) = “F49” “Y“ . (4*5) = “Y20“

Variabili scalari

• Case sensitive

• Il valore di una variabile ‘nomevar’ e’ sempre identificato con $nomevar

• Operatori di assegnazione binaria : += *= .= • Autoincremento, autodecremento: ++$a $a++ • Operatore chomp(argomento): trasforma stringhe DOS in Unix

• Operatore chop(argomento) : elimina l’ultimo carattere dell’argomento. Ritorna il carattere eliminato Es. chop($a=<STDIN>) ;

 • Interpolazione di variabili scalari in stringhe delimitate da “”Es. $a=”bla bla $b bla bla” ; • Se la variabile inserita viene seguita subito da testo, si puo’ usare il delimitatore {}Es. $a=”blabla${b}bla” ; stesso risultato di $a=”blabla$b”.”bla” ; 

Variabili predefinite

• $$ PID del programma

• $< UID reale dell’utente che esegue il programma

• $> UID effettivo dell’utente

• $? stato dell’ultima chiamata

• $_ argomento predefinito

• $0 nome del programma

• $” separatore di lista

• $/ separatore di righe per l’input

Array e liste in PERL

• Liste: sequenze di scalari separati da virgole tra parentesi tonde. Usate per inizializzare array.

• Variabili di tipo Array : individuate con il carattere @@a=(1,2,3) ;@a=1 ; # array di un solo elemento@b=@a ;@a=(“uno”, “due”, “tre”) ;@b=(1,2,@a,3) ; # @b contiene (1,2,”uno”,”due”,”tre”,3)

 • Uso di variabili nell’array.

($a, $b, $c) = (1,2,3) ; #inizializza le variabili $a $b $c($a, $b) = ($b, $a) ; #inverte($d, @z) = ($a, $b, $c) ; #risultato : $d=$a, @z=($b, $c)($e, @z)=@z ; #risultato : $e=$b, @z=($c)

  • Assegnazione scalare=array : la var scalare contiene il numero di elementi

@a=(1,2,3) ;$b=@a ; #risultato : la var b contiene 3($b) = @a ; # la var b contiene il primo elemento di @a

• Accedere ad un elemento non definito ritorna undef ; assegnare un elemento non definito estende l’array

Accesso agli elementi di un array• Array predefinito @ARGV argomenti dello script PERL

• Gli elementi di un array sono indicizzati da 0@a=(1, 2, 3) ;$b=$a[0] ; # $b contiene 1$a[0]=4 ; # @a = (4,2,3)$a[1]++; $a[2] += 4;

 • L’array puo’ essere raggruppato in parti:

@b=@a[0,1] ; # equivale a @b=($a[0], $a[1]) ;@a[0,1]=(x,y) ; # come @a=(x,y)@b=(1,2,3)[2,3]; # come @c=(1,2,3) @b=@c[2,3] $x=0 ; $y=1 ; @b=(1,2,3)[$x,$y] ;@z=($x,$y) ; @b=(1,2,3)[@z] ;

 • Interpolazione di elementi di array in variabili:

@a=(1,2,3) ;$b=”bla bla $a[1] bla” ;$b=”bla bla @a bla” ;$b=”blabla @a[1,2] bla” ;

Operatori per array• Minimo e Massimo indice di un array : $[a $#a

• push() e pop() :aggiungono e tolgono elementi dal lato destro dell’array.push(@a,$x) ; # come @a = (@a, $x)$old=pop(@a) ;push(@a,$x,$y,$z) ;

 • shift() e unshift() : tolgono e aggiungono elementi dal lato sinistro dell’array

unshift(@a, $x) ; #come @a=($x,@a)$x=shift(@a) ; #come ($x,@a)=@a

 • reverse() : inverte l’ordine degli elemeti di un array • sort() : ordina un array in senso ascendente.

@a=sort(@a) ;

 • Accesso ad un elemento: $a[$b]

• chop() : se applicato ad un array, elimina l’ultimo elemento.  • Lettura da tastiera con <STDIN>

@a=<STDIN> ; #legge dallo standard input ogni riga in un elemento dell’array. 

Il ciclo for

• Sintassi: 

for(condizione iniziale; condizione finale; incremento) {istruzioni;

} • Esempio : stampa di un array

#!/user/local/bin/perl@v = (“lun”, “mar”, “mer”, “gio”, “ven”, “sab”);for($i=0; $i<=$#v; $i++){ print “$v[$i]\n”; }

• Struttura foreach $varloop: la variabile di loop e’ un riferimento ad ogni elemento dell’array. L’array puo’ essere modificato. Se non indico la variabile variabile implicita $_Esempio : stampa di un array#!/user/local/bin/perl@v = (“lun”, “mar”, “mer”, “gio”, “ven”, “sab”);foreach $a(@v){ print “$a\n”; }

Array associativi

• Collezione di dati scalari, individuati dal valore delle chiavi.

Coppie (chiave-dato) indirizzata per chiave

%a=(“a”, dato_a, “b”, dato_b, “c”, dato_c);

•  Accesso agli elementi di %a: $b=$a{$chiave};print $a{“a”};

print $a{“b”};

•  Inizializzazione elemento per elemento:$a{“a”} = “dato_a”;

$a{“b”} = “dato_b”;

•  Principali operatori per gli array associativi– keys() ritorna la lista di tutte le chiavi

@lista = keys(%a); # ritorna (“a”, “b”, “c”);

foreach $key (keys(%a)){

print “alla chiave $key corrisponde $a{$key}” # stampa la coppia chiave/valore

}

–  each() ritorna la coppia (chiave, dato)

while( ($x,$y) = each(%a)) { print “$x $y”; }

–  delete cancella un elemento dell’array associativo tramite la chiave

delete $a{“a”};

Struttura condizionata• Struttura if-else

if(condizione){ if(condizione) {primo blocco di istruzioni ; istruzioni ;

}else { } elsif (condizione) {secondo blocco di istruzioni ; istruzioni ;

} } elsif(condizione) {…..}

• Struttura postfissa (singola istruzione): istruzione if condizione;• Se l’espressione e’ una stringa di singoli caratteri, l’espressione e’ valutata così :

se “0” => falso . Se non “0” => vero. 0, “0” falso

“0” falso1-1 falso0 “0” falso“00” vero

1 vero“” falso

 • unless : realizza la parte else dell’if :

 unless(condizione){secondo blocco di istruzioni ;

}

Struttura condizionata

• Le istruzioni ritornano un valore vero se sono andati a buon fine istruzioni come condizioni.

– Struttura if(PrimaIstruzione) {SecondaIstruzione;}– Realizzazione in PERL PrimaIstruzione && SecondaIstruzione;

– Struttura if( ! PrimaIstruzione) {SecondaIstruzione;}– Realizzazione in PERL PrimaIstruzione || SecondaIstruzione;

• Precedenze degli operatori

• Uso di ‘die’: istruzione || die “errore”

Strutture while/until• Sintassi

while(espression){ until(espressione){istruzioni ; istruzioni ;

} } • Esempi: lettura di un file.

#!/user/local/bin/perlopen(f, “< nomefile”) || die “errore di apertura file”;while($r = <f>) { print $r; }close(f);

• Stampa di un array.#!/user/local/bin/perl@v = (“lun”, “mar”, “mer”, “gio”, “ven”, “sab”);while(@v) {

$giorno = shift @v;print “$giorno\n”;

}

Input/Output• Lettura da <STDIN>

$a = <STDIN> #legge una linea

@a = <STDIN> #legge tutte le linee fino a ^d

while(<STDIN>){ #legge in $_

chop; #agisce su $_

print “$_” # … elabora $_

}

 • Operatore diamante < > : legge una riga alla volta dai file forniti come argomenti dello

script. NB: i nomi vengono prelevati dall’array @ARGV

script ‘prova’#!/usr/local/bin/perl

while(<>) {

print $_

}

  prova file1 file2 …

 • Uscita su STDOUT con print.

$a = print(“blabla \n ») ; #ritorna vero o falso

print(“%s %d %f\n”, $a, $b, $c); #print formattato

Gestione dei file in PERL

• Gestione dei file attraverso i file handle • Apertura di un file handle: open(nome file handle, “nome file”);

– open ritorna vero o falso– per aprire in scrittura: open(OUT, “>nome file”);– aggiungere al file: open(OUT,”>>nome file”);– apertura in lettura: open(IN,”nome file”);

• Spostamento del puntatore al file: seek(puntatore, posizione, partenza)

• Operatore die(“…”): scrive il messaggio e poi esce dal processounless(open(OUT,”>file”)){

die(“errore\n”);} else{

print(“ok\n”); #resto del programma;

}

oppure: open(OUT,”>file”) || die(“errore\n”);

Gestione dei file in PERL• Lettura file:

open(IN, “file”);while(<IN>){

chop; print “linea letta= $_ \n”:}close(IN);

 • Copia file:

open(IN, “file_in”);open(OUT, “>file_out”);while(<IN>){

chop; print(OUT, $_);}close(IN); close(OUT);

 • Test sui file:

-r file leggibile -w file eseguibile-x file o directory eseguibile -o appartiene all’utente-R leggibile dall’utente reale, non effettivo -W scrivibile dall’utente reale-X eseguibile dall’utente reale -O appartiene all’utente reale-e il file esiste

Gestione dei file in PERL

• Test sui file-z il file esiste ma ha dimensione nulla -s esiste ed ha dimensione

non nulla

-f file regolare -d direttorio

-l link simbolico -s socket

-p pipe con nome (fifo) -b file speciale a blocchi

-c file speciale a caratteri -uil file o directory ha setuid settato

-g bit setgid settato -k sticky bit settato

-T file testo

-B file binario -M tempo dall’ultima modifica in giorni

-A tempo dall’ultimo accesso in giorni

-C tempo dall’ultima modifica dell’inode in giorni

 • Operatore stat(file name) : ritorna informazioni dettagliate sui file.

($dev, $ino, $mode, $nlink, $UID, $gid, $rdev, $size, $atime, $mtime, $ctime, $blksize, $blocks) = stat(“nome”);

 • Per selezionare le informazioni: ($uid, $gid) = (stat(“nome”))[4,5];

 • Operatore lstat(nome): ritorna informazioni dettagliate su un link

simbolico (stat su un link simbolico fornisce informazioni sul file puntato)

Gestione delle directories• Operatore chdir:

chdir(“directory”) || die

 • Espansione degli argomenti (globbing): lista dei file corrispondenti alla

espansione di *:@a = <*>;@a = <path*>;

  while($b = <*>) {print “$b”;

}

 • Operatori opendir/closedir: gestione delle directory handle:

opendir(ETC,”/etc”) || die(“errore\n”);

 • Operatore readdir(handle) : ritorna un nome file ($a=readdir) o tutti i nomi file

(@a=readdir) contenuti nella directory 

opendir(ETC,”/etc”) || die; #nomi in ordine alfabetico.foreach $a (sort readdir(ETC)){

print “$a\n”;}closedir(ETC);

Gestione file in PERL• Cancellazione: unlink(nome). Ritorna il nr di file cancellati

unlink(“nomefile”);unlink(“file1”, “file2”, “file3”);unlink(<*.txt>);

  foreach $a (<*.txt>) {unlink($a) || die;

}  foreach (<*.txt>){

unlink || die(“errore $_ \n”);}

 • Operatore rename($old, $new); rinomina file. • Operatore link, symlink: introduce un link ad un file

Link(“old”,”new”)||die; #hard linkSymlink(“old”, “new”) || die; #link simbolico

 • Operatore mkdir(): crea subdirectories

Mkdir(“nomedir”, 0777);

 • Operatore rmdir: cancella subdirectories

Rmdir(“nomedir”);

Gestione file in PERL• Operatore chmod() modifica i permessi del file; ritorna il nr di file modificati con successo

$a=chmod(0666,”nomefile”);Foreach $file (“nome1”, “nome2”){

Unless (chmod(0666, $file)) {Print “errore nella modifica dei permessi!!\n”

}}

 • Operatore chown: modifica proprietario/gruppo

chown(UID, GID, “file”);

 • Operatore utime(ultimo accesso, ultima modifica, files): modifica I tempi

Tempi associati ad un file: data ultimo accesso, data ultima modifica, data ultima modifica dell’inode

 • Operatore time (ritorna il tempo corrente):

$a=time - 20*60; # 20 minuti da orautime($a, $a, “nome_file1”, “nome_file2”, …); # i file indicati sono aggiornati a 20 minuti fa

Gestione processi in PERL

• Creazione processi con istruzioni fork/exec/wait: crea un clone del processo corrente. Fork ritorna 0 al figlio !0 al padre

If(fork){ Print “sono il padre”; }else{ print “sono il figlio”; exec(“date”); }

unless (fork) {exec(“date”); # sono qui perche’ fork ritorna 0

}wait;

 • Exi : uscita da un processo • Variabile d’ambiente: l’ambiente viene messo nell’array associativo %ENV

forach $a (sort keys %ENV){ # elenca le variabili d’ambientePrint “$a = $ENV{$a}\n”;

} $oldpath=$ENV(“PATH”); # modifica le variabili d’ambiente$ENV(“PATH”) = “ bla nuovo PATH bla”;

…$ENV(“PATH”) = $oldpath;

Espressioni regolari in PERL• ER: espressione costruita secondo una sintassi che ci permette di descrivere

una stringa• Pattern matching: verifica se una stringa o una sua sottostringa corrisponde ad

una ER.• In PERL con variabile implicita: m/ER/ (m può essere omesso.)• Esempio: funzione grep #!/usr/local/bin/perl

while(<>){ if(/er/){ Print”$_”; } }

• In PERL con variabile esplicita: operatore di match =~ Applica una espressione regolare ad una variabile che non sia $_

$a=”blablabla”;

if($a =~ /^b/){

print $a #stampa $a se la stringa inizia con b

}

  print “continuare? (S/s o N/n)”

if(<STDIN> =~ /^[Ss]/) {

print “hai risposto si!”

}

 

• Caratteri maiuscoli o minuscoli (ignora il case) con l’opzione i: /er/i

Espressioni regolari in PERL

• Esempio: stampare tutte le righe di un file che contengono una stringa fornita dall’utente.

#!/user/local/bin/perl

print “dare il nome del file: “;

$nome=<STDIN>;

chop/$nome);

-e $nome || die “file non esistente\n”;

-T $nome || die “file non e’ di testo\n”;

print “dare la stringa: “;

$str = <STDIN>;

chop($str);

open(f, “< $nome”) || “impossibile aprire il file\n”;

while ($r = <f>){

$r = ~/$str/ && print$r;

}

close(f):

Espressioni regolari in PERL• Una ER puo’ contenere variabili. Le variabili vengono espanse prima di considerare

eventuali caratteri speciali.

$a=”abc def ghi”;print “scrivi una parola di 3 caratteri”;$b=<STDIN>;chop($b);if($a =~ /z$b/){

print “trovato z$b in $a\n”;} else {

print “non trovato\n”;}

 • Sostituzione in PERL: s/old-ER/new-ER/

$_=”abc def ghi”;s/abc/xyz/g; #tutte le stringhe /abc/ vengono

sostituite 

$a=”abc def ghi”; #caso in cui ho una variabile esplicita

$a =~ s/abc/xyz/g; 

Espressioni regolari in PERL

• Operatore split(espressione regolare , stringa) : ritorna un vettore formato dalle parti della stringa che NON corrispondono alla ER

$a=”a:b:c:d”;

@b=split(/:/, $a);# @b contiene (a, b, c ,d)

@b=split(/er/);# in questo caso la stringa e’ $_

 • Operatore join($glue, @lista): riunisce gli elementi della lista attraverso

$glue in una stringa

$a = join(“:”, @b); #ricostruisce la stringa precedente

Funzioni in PERL• Il programmatore puo’ definire delle subroutine nella forma

sub nome{ #i parametri passati si trovano in @_, quindi $_[0], $_[1] …

istruzioni;return (valore);

}

• Chiamata della subroutine: &nome• Visibilità:

– Le variabili locali definite con local(lista_variabili) le variabili sono visibili nella subroutine e nelle subroutine chiamate

– Le variabili definite con my(lista variabili) sono visibili solo dove sono dichiarate.

• Le funzioni sono ricorsive:#!/user/local/bin/perl#script fattoriale.plSub fattoriale{

local($n) = shift(@_);($n==1) && return (1);return($n * &fattoriale($n-1);

}$n=<STDIN>;$r=&fattoriale($n);Print “fattoriale di $n = $r\n”;

Funzioni in PERL• Uno script PERL può richiamare programmi esterni o comandi Unix.

– Mediante apici inversi@r=`cat $file | grep $s | sort`

– Mediante system o execsystem() lo script aspetta la terminazione del programma esternosystem(“comando di shell”) && die;system(“comando1; comando2 > filek&”) && die;system(“comando > file”) && die;

exec() lo script termina e continua il programma esterno

– Mediante apertura di canali di pipe:open(OUT, “| more”) || die “errore\n”;foreach $r(@array) {

print OUT $r;}close(OUT);

……open(HANDLE, “who|”); #lettura@a = <HANDLE>; close(HANDLE);

 ........open(HANDLE, “|cat”); #scritturaprint(HANDLE,”stringa da stampare con cat”); close(HANDLE);

Funzioni in PERL• Attenzione: oltre a return, esiste un altro metodo di passaggio parametri: il/i

valori di ritorno sono gli ultimi valutati!

• Lista di tutti gli elementi maggiori di A:  sub somma{

local($n,@a); ($n,@a) = @_; local(@b);for($i=1;$i<$n; $i++){

if($a[$i]> A)push(@b, $a[$i]);

}@b;

}@a=&somma(100,@lista);

 • Lista di tutti gli elementi maggiori di A:

sub somma{local($n,@a); ($n,@a) = @_; local(@b);foreach $_ (@a){

if($_ > A)push(@b, $_);

}@b;

}@a=&somma(100,@lista);

Seconda parte.Esempi di programmazione

#!/usr/local/bin/perl

#

# legge dallo standard input delle parole e conta le occorrenze

@words = <STDIN>; # leggi le parole dallo standard in

foreach $word (@words) {

chop($word); # rimuove il newline

$count{$word}++ ;

}

foreach $word (keys %count) {

print "$word appare $count{$word} volte\n";

}

#!/usr/local/bin/perl# conta le occorrenze dallo standard inwhile(<STDIN>){ chop; $a{$_}++; }foreach $b (keys(%a)){ print "La parola $b appare $a{$b} volte\n"};

#!/usr/local/bin/perl# legge parole da filewhile(<>){ chop; $a{$_}++; }foreach $b (keys(%a)){ print "La parola $b \t appare $a{$b}\t volte\n"};

#!/usr/local/bin/perl#Legge una lista di stringhe e le stampa con formato desideratoprint "Field width: ";chop($width = <STDIN>);print "List of strings:\n";chop(@strings = <STDIN>);foreach (@strings) { printf "%${width}s\n", $_;}

#!/usr/local/bin/perl

#

while (<STDIN>) {

($user, $pass, $uid, $gid, $gcos) = split(/:/);

($real) = split(/,/, $gcos);

($first) = split(/\s+/, $real);

$seen{$first}++;

}

foreach (keys %seen) {

if ($seen{$_} > 1) {

print "$_ visto $seen{$_} volte\n";

}

}

#!/usr/local/bin/perl# questo script sostituisce stringhe in un file#print "Input file name: ";chop($infilename = <STDIN>);print "Output file name: ";chop($outfilename = <STDIN>);print “Stringa da cercare: ";chop($search = <STDIN>);print “Stringa da rimpiazzare: ";chop($replace = <STDIN>);open(IN,$infilename) || die “non posso aprire $infilename in lettura";## test opzionale per sovrascrivere...die “non sovrascrivo $outfilename" if -e $outfilename;open(OUT,">$outfilename") || die “non posso creare $outfilename";while (<IN>) { # leggi una linea dal file $a in $_

s/$search/$replace/g; # cambia le lineeprint OUT $_; # scrivi quella linea nel file $b

}close(IN);close(OUT);

#!/usr/local/bin/perl

#

while (<>) {

chop;

($age) = (stat("$_"))[8];

# $age= -M; # l'operatore -M ritorna la data dell'ultima modifica

print "file $_ age $age\n";

if ($newest_age < $age) {

$newest_name = $_;

$newest_age = $age;

}

}

print “Il file piu’ recente e’$newest_name ",

“e ha $newest_age giorni.\n";

#!/usr/local/bin/perl#print “quale directory? ";chop($newdir = <STDIN>);chdir($newdir) ||

die “Non posso spostarmi in $newdir";opendir(DOT,".") || die “non posso aprire la directory";foreach (sort readdir(DOT)) { print "$_\n"; }closedir(DOT);

#!/usr/local/bin/perl@a = <*>;foreach $nomefile(sort(@a)){ print "$nomefile\n";}

#!/usr/local/bin/perl#open(PW,"/etc/passwd");while (<PW>) { chop; ($user,$pw,$uid,$gid,$gcos) = split(/:/); ($real) = split(/,/, $gcos); $real{$user} = $real;}close(PW);

open(WHO,"who|") || die “non posso aprire la pipe";while (<WHO>) { ($login, $rest) = /^(\S+)\s+(.*)/; $login = $real{$login} if $real{$login}; printf "%-30s %s\n",$login,$rest;}

#!/usr/local/bin/perl

&init;

print “Nome utente? "; $name = <STDIN>; chop($name);

print "Password? "; $pass = <STDIN>; chop($pass);

while ($pass ne $words{$name}) {

print "password errata! riprova: "; $pass=<STDIN>; chop($pass);

}

print "ok\n";

exit;

sub init{

open(WORDLIST, "wordlist");

while($name=<WORDLIST>){

chop($name); $word= <WORDLIST>; chop($word); $words{$name} = $word;

}

close(WORDLIST);

}

#!/usr/local/bin/perlsub test{if ($#ARGV<0) {print "Specifica il file... \n";exit; }}&test;print "N. parametri: ", $#ARGV+1," Pid:$$ \n";$i=1;foreach $a (@ARGV) {

print "parametro n. $i:$a \n";$i++;

}open (IN,"$ARGV[0]");print "Contenuto del file:\n";while ($a=<IN>) {

print $a;};

close (IN);

#!/usr/local/bin/perlsub test{if ($#ARGV<0) {print "Manca il nome del file. \n";exit; }}&test;print "N. parametri: ",$#ARGV+1," Pid:$$ \n";

for ($i=0;$i<=$#ARGV;$i++) {print "parametro n. ",$i+1,": $ARGV[$i] \n";

}

open (IN,"$ARGV[0]");print "Contenuto del file:\n";while (@a=<IN>) {

foreach $b(@a) {print $b; }

};

close (IN);

#!/usr/local/bin/perlsub test{if ($#ARGV<0) {print "Inserisci il nome del file... \n";exit; }}

&test;open (IN,"$ARGV[0]");while ($a=<IN>) {

chop($a);@b=split(/,?\s+/,$a);foreach $c (@b) {

$occor{$c}++;};

};close (IN);

foreach $a (keys (%occor)) {print "Parola [$a] -> occorrenze: $occor{$a}\n";};

#!/usr/local/bin/perl

sub test{if ($#ARGV<0) {print "Inserire il nome del file. \n";exit; }}

&test;

while (<>) {chop;@b=split(/,?\s+/);foreach $c (@b) {

$occor{$c}++;};

};

foreach $a (keys (%occor)) {print "Parola [$a] -> occorrenze: $occor{$a}\n";};

#!/usr/local/bin/perlsub test{if ($#ARGV<0) {print "Inserire il nome del file... \n";exit; }}&test;open (IN,"$ARGV[0]");while (@a=<IN>) {

foreach $b (@a) {chop($b);@c=split(/,?\s+/,$b);foreach $d (@c) {

$occor{$d}++;};

};};

close (IN);foreach $a (keys (%occor)) {

print "Parola [$a] -> occorrenze: $occor{$a}\n";};

#!/usr/local/bin/perlsub test{ if($#ARGV<2){ print"Errore! \n";

print"Sintassi : perlex3 file vecchia_stringa nuova_stringa\n";

exit; }}&test;unless(open(FILE,"$ARGV[0]")){ print"errore nell'apertura del file\n"; exit;}@testo=<FILE>;close(FILE);$i=0;@temp;foreach $riga(@testo){

$riga =~ s/$ARGV[1]/$ARGV[2]/g;$temp[$i]=$riga;$i++;

}print "Risultato:\n"; print @temp; print "\n";

#!/usr/local/bin/perlprint "Nome file di input: ";$file = <STDIN>;chop($file);-e $file || die "Il file non esiste!\n\n";-T $file || die "Il file non e' un file di testo!\n\n";print "Stringa da cercare: ";$stringa = <STDIN>;chop($stringa);print "Stringa da sostituire: ";$sost = <STDIN>;chop($sost);open (IN, "< $file") || die "Impossibile aprire $file.\n\n";$i=0;@temp;while ($r = <IN>) { $r =~ s/$stringa/$sost/g; $temp[$i]=$r; $i++;}close(IN);print "Risultato: \n";print "@temp";

#!/usr/local/bin/perlsub test{ if($#ARGV<1){ print"Mancano parametri\n"; exit; }}&test;unless(open(FILE,"$ARGV[0]")){ print"Errore in apertura di $ARGV[0]\n"; exit;}@testo=<FILE>;close(FILE);$i=0;foreach $riga(@testo){

chop($riga);@campo=split(/\s+/,$riga);if($campo[0]=~/$ARGV[1]/) { $i++ };

}print "Righe di $ARGV[0] contenenti nel primo campo $ARGV[1] :

$i\n";

#!/usr/local/bin/perlsub load {

open (F,"PASS");while (<F>) {

chop;@a = split(/\s/);$PASS{$a[1]} = $a[0];

}}&load; print "username: ";$user = <STDIN>;chop ($user);print "chiave: ";$chiave = <STDIN>;chop ($chiave);# cancello eco?????????????if ($PASS{$chiave} eq $user) {

print "\nChiave esatta!";print "\nOra puoi accedere alle risorse protette!\n";}

else {print "\nSpiacente: non puoi entrare!\n"};

#!/usr/local/bin/perl@d = <*>;foreach $nomefile(@d){ $size = (stat($nomefile))[7]; $dim{$size} = $nomefile;#print "$nomefile -> $size\n";}@s = sort(keys(%dim));$numtot = @s;$medium=int(${numtot}/2);$medio = @s[$medium];$grande = pop(@s);$piccolo = shift(@s);print "\nIl file piu' grande e': $dim{$grande}

($grande bytes)";print "\nIl file piu' piccolo e': $dim{$piccolo}

($piccolo bytes)";print "\nIl file medio e': $dim{$medio} ($medio bytes)\

n";

#!/usr/local/bin/perl

@d = <*>;print "\n # = 100 bytes\n";

foreach $nomefile(@d){ @a = stat ($nomefile); $size = $a[7]; $quad = $size/100; printf("%-15s %+10s ", $nomefile, $size); for($i=0;$i<$quad;$i++) {

printf( "#"); } printf("\n");}

#!/usr/bin/perl#argomento: nomefile -opzione

sub test{ if ($#ARGV < 1) {print "errore\n"; exit 1;} } &test;foreach $a(@ARGV){print "parametri: $a\n";}print "Il PID del processo e' $$\n";

open(FILE, "$ARGV[0]");while ($a=<FILE>) { chop ($a) ; print "$a\n"; }close(FILE);

#!/usr/bin/perl# argomento: nomefile -opzione

sub test{ if ($#ARGV < 1) {print "errore\n"; exit 1;} } &test;for ($i=0;$i<=$#ARGV;$i++){print "parametri: $ARGV[$i]\

n";}print "Il PID del processo e' $$\n";

open(FILE, "$ARGV[0]");while ($a=<FILE>) { chop ($a) ; print "$a\n"; }close(FILE);

#!/usr/bin/perl

# argomento: nomefile -opzione

sub test{

if ($#ARGV < 1) {print "errore\n";

exit 1;}

}

&test;

foreach $a(@ARGV){print "parametri: $a\n";}

print "Il PID del processo e' $$\n";

open(FILE, "$ARGV[0]");

@a=<FILE>;

foreach $b(@a) {

chop ($b) ;

print "$b\n";

}

close(FILE);

#!/usr/bin/perl#argomento: nomefile

sub test{ if ($#ARGV !=0) {

print "errore\n"; exit 1;} } &test;print "Nome File: $ARGV[0]\n";open(FILE, "$ARGV[0]");while ($a=<FILE>) { chop ($a) ; @b=split(/,?\s+/,$a); foreach $c(@b){ $occor{$c}++; }

}foreach $c(keys %occor){ print "$c $occor{$c}\n"; }close(FILE);

#!/usr/bin/perl# argomento: nomefile

sub test{ if ($#ARGV !=0) {print "errore\n"; exit 1;} } &test;print "Nome File: $ARGV[0]\n";open("$ARGV[0]");while (<>) { chop ; @b=split(/,?\s+/); foreach $c(@b){ $occor{$c}++; } }foreach $c(keys %occor){ print "$c $occor{$c}\n"; }close(FILE);

#!/usr/bin/perl# argomento: nomefilesub test{ if ($#ARGV !=0) {print "errore\n"; exit 1;} }&test;print "Nome File: $ARGV[0]\n";open(FILE, "$ARGV[0]");@a=<FILE>;foreach $d(@a){ chop ($d) ; @b=split(/,?\s+/,$d); foreach $c(@b){ $occor{$c}++; }

}foreach $c(keys %occor){ print "$c $occor{$c}\n"; }close(FILE);

#!/usr/bin/perl#argomento: nomefile "er_old" "er_new"

sub test{ if ($#ARGV <2) {print "errore\n"; exit 1;} } &test;print "Nome File: $ARGV[0]\n";open(IN,"$ARGV[0]");open(OUT, ">$ARGV[0]new");while (<IN>) { s/$er_old/$er_new/g; print OUT $_; }close(IN); close(OUT);

#!/usr/bin/perl#print "Nome File Input:\n";chop ($infile=<STDIN>);print "Nome file Output:\n";chop ($outfile=<STDIN>);print "Espressione Regolare da sostituire:\n";chop ($er_old=<STDIN>);print "Espressione Regolare sostituta:\n";chop ($er_new=<STDIN>);

open (IN, $infile) || die "Non posso aprire il File $infile\n";open (OUT, ">$outfile") || die "Non posso creare il File $outfile\n";while (<IN>){ s/$er_old/$er_new/g; print OUT $_; }close(IN); close(OUT);

#!/usr/bin/perl#argomenti: nomefile "separatore_campi" "primo_campo"

sub test{ if ($#ARGV < 2) {print "errore\n"; exit 1;} }&test;print "nome file: $ARGV[0]\n";print "numero di righe in cui il primo campo è $ARGV[2] :\n";open (FILE, $ARGV[0]) || die "Non posso aprire il file\n";$i=0;while (<FILE>){ chop; @b=split(/$ARGV[1]/); if ($b[0] eq $ARGV[2]){ $i=$i+1} }print "$i\n";

#!/usr/bin/perl#

open (F, "passwd");while ($l=<F>) { chop($l); @a=split(/\s+/,"$l"); $pass{$a[1]}=$a[0]; } print "User Name:\n";chop($user=<STDIN>);print "Password:\n";chop($p=<STDIN>);

if ($pass{$p} eq $user) { print "Utente autorizzato\n"; #lista istruzioni }

else { print "Utente non autorizzato\n"; }

#!/usr/bin/perl

#

#elenca in ordine alfabetico i file regolari contenuti nella directory

@a=<*>;

@a=sort(@a);

foreach $b(@a){ if ( -f "$b"){ print "$b\n"}

}

#!/usr/local/bin/perl$i=0;while ($b=<*>){ if ( -f "$b" ){ @a=stat($b); $elenco{$b}=$a[7]; $dim[$i]=$a[7]; $i++; } }@dim=sort {$a<=>$b} @dim; $m=($#dim/2);foreach $b(keys(%elenco)){ if($elenco{$b}==$dim[-1]) {push(@max,$b)} if($elenco{$b}==$dim[0]) {push(@min,$b)} if($elenco{$b}==$dim[$m]) {push(@med,$b)} }if ($#max==0) { print "Il File piu'grande e': $max[0] $dim[-1] bytes\n"} else { print "I Files piu' grandi sono :\n"; foreach $b(@max){ print "$b $dim[-1] bytes\n"} }if ($#med==0) { print "Il File mediano e': $med[0] $dim[$m] bytes\n"} else{ print "I Files mediani sono :\n"; foreach $b(@med){ print "$b $dim[$m] bytes\n"} }if ($#min==0){print "Il File piu' piccolo e': $min[0] $dim[0] bytes\n"} else{ print "I Files piu' piccoli sono :\n"; foreach $b(@min){ print "$b $dim[0] bytes\n"} }

#!/usr/bin/perl

#visualizza un istogramma delle dimensioni dei file regolari

$i=0;

$max=0;

while ($b=<*>) { if ( -f "$b"){ @a=stat($b);

$size=$a[7];

$nomi[$i]=$b;

$dim[$i]=$size;

$i=$i+1;

if($size>$max){ $max=$size }

}

}

$scala=($max/60);

print "ISTOGRAMMA DIMENSIONE FILES\n";

print "Ogni \"o\" corrisponde a $scala bytes\n";

$i=0;

foreach $n(@nomi){ $simboli[$i]=("o"x($dim[$i]/$scala));

$spazio="-"x(15-length($n));

print "$n $spazio |$simboli[$i]\n";

$i=$i+1;

}

Terza parte.Argomenti avanzati.

• Moduli e packages

• Oop

• Processi e IPC

• Socket

Moduli

I moduli sono scritti per portare a termine dei compiti che non sono implementati dalle funzioni integrate del PERL o che potrebbero essere implementati in modo diverso (migliore).

I moduli sono composti da package.

Finalità:

• produzione di codice riutilizzabile

• utilizzo di moduli standard (o core) distribuiti con PERL

Spazi dei nomiSpazi dei nomiMemorizza nomi di: variabili, subroutine, filehandle, formati.Lo spazio dei nomi predefinito dei programmi è main.

In PERL uno spazio dei nomi contenuto in un package.

Da un package è possibile fare riferimento alle variabili di un altro, qualificandole con

il nome del pacchetto.

$Package::varname

$::var$main::var

Moduli

Per utilizzare i moduli si usano le parola chiave require o use.

require Module;

use Module;

use Module qw(const1 const2 func1);

use carica il modulo in fase di compilazione

require richiede di qualificare in modo esplicito le sue routine con il nome del pacchetto

OOP

Definizione di classi e oggettiUn modulo descrive una classe e deve contenere una subroutine specialeper la creazione di un oggetto (costruttore).

Il costruttore crea un nuovo oggetto e restituisce un riferimento.

All’interno dei programmi, il riferimento è usato per manipolare l’oggetto.

I metodi sono delle subroutine che si aspettano come primo argomento un riferimento a un oggetto:

sub in_class { my $class = shift; #riferimento a un oggetto my ($this, $that) = @_; #parametri}

OOP

I metodi possono essere invocati nei seguenti modi:

$PackageName->constructor(args)->method_name(args);

$object = PackageName->Constructor(args);

$object->method_name(args);

I costruttori degli oggetti si invocano con new.

Un oggetto è distrutto quando scompare anche il suo ultimo riferimento.

Creazione Processi

Nel corso dell’esecuzione di un processo, ci sono vari modi per lanciare

in esecuzione un altro processo:

exec lancia l’esecuzione di un nuovo processo e termina definitivamente

l’esecuzione del programma chiamante

system avvia l’esecuzione di un nuovo processo e riprende

l’esecuzione del processo originario solo al termine dell’esecuzione

del nuovo processo

fork genera un clone del processo padre

Creazione Processi

#!/usr/bin/perl -w# programma che esegue la chiamata di sistema fork

print "Nome: exfork1\n";$pid=fork();if ($pid) { # $pid=0, sono il PADRE print "p->\$pid=$pid\n"; print "Sono il padre!\n"; exit(0);} else { # $pid=0, sono il FIGLIO print "c->\$pid=$pid\n"; print "Sono il figlio!\n"; exit(0);}

Sincronizzazione

La sincronizzazione tra processi può essere fatta in vari modi:

• invio di segnali

• semafori

• pipe e fifo

• scambio di messaggi

• memoria condivisa

• socket

In Linux sono implementate le chiamate di sistema

IPC System V (standard UNIX).

Semafori

Principio base: si controlla lo stato di una variabile (semaforo) che viene aggiornato con operazioni atomiche (non interrompibili).In realtà i semafori delle IPC System V sono dei semafori con contatore.

semget definisce un semaforo e ne restituisce l’ID

semop operazione sul semaforo OCCUPAZIONE RISORSA

se la risorsa libera, e incremento del contatore semaforo (pone il semaforo a ROSSO)

RILASCIO RISORSAdecremento contatore semaforo (pone il Semaforo a VERDE)

semctl controllo semaforo

Semafori

Creazione del semaforo

use IPC::SysV qw(IPC_CREAT);$IPC_KEY = 1234;$id = semget($IPC_KEY, 10, 0666 | IPC_CREAT ) || die "$!";print "sem key $id\n";# crea il semaforo e visualizza l’id a schermo

Utilizzo di semaforo già creato

$IPC_KEY = 1234;$id = semget($IPC_KEY, 0 , 0 );die if !defined($id);

Semafori

Blocco del semaforo

# aspetta che il semaforo diventi zero

$semop = 0;

$opstring1 = pack("s!s!s!", $semnum, $semop, $semflag);

# ...e incrementa il contatore del semaforo

$semop = 1;

$opstring2 = pack("s!s!s!", $semnum, $semop, $semflag);

$opstring = $opstring1 . $opstring2;

semop($id,$opstring) || die "$!";

Semafori

Rilascio del semaforo

$semnum = 0;

$semflag = 0;

# Decrementa il contatore del semaforo

$semop = -1;

$opstring = pack("s!s!s!", $semnum, $semop, $semflag);

semop($id,$opstring) || die "$!";

Memoria Condivisa

è la tecnica di comunicazione tra processi più veloce, viene predisposta dal sistema operativo una zona di memoria che puòessere utilizzata da tutti i processi che lo richiedono con la chiamata shmget().

Gli accessi ai dati devono essere regolati, in modo che più processinon accedano contemporaneamente alla stessa zona dati, causandoproblemi di consistenza dei dati (ad es. più processi che scrivonocontemporaneamente sulla zona dati) utilizzando per es. semafori.

ID=shmget(KEY,SIZE,FLAGS) definisce una zona di memoria condivisashmread(ID, VAR, POS, SIZE) legge dal segmento ID di memoria

condivisa, dalla posizione POS per SIZE byte. Azioni: attach, legge, detach

shmwrite scrive sulla memoria condivisashmctl controllo memoria condivisa

#!/usr/bin/perl –w# shared memoryuse IPC::SysV qw(IPC_PRIVATE IPC_RMID S_IRWXU);

$size = 2000;$id = shmget(IPC_PRIVATE, $size, S_IRWXU) || die "$!";print "shm key $id\n";

$message = "Messaggio #1";shmwrite($id, $messaggio, 0, 60) || die "$!";print “scritto: '$messaggio'\n";

shmread($id, $buff, 0, 60) || die "$!";print “letto : '$buff'\n";

# the buffer of shmread is zero-character end-padded.substr($buff, index($buff, "\0")) = '';print "un" unless $buff eq $message;print "swell\n";

print “cancello shm $id\n";shmctl($id, IPC_RMID, 0) || die "$!";

Pack - Unpack

• Pack: codifica secondo il formato richiesto numeri o stringhe.– Es.: formato ‘C’ un char, ‘CCCC’ 4 char,

‘l’ intero con segno di 4 byte, ‘ll’ 8 byte– $a=pack(“CCCC”,140,105,50,61);

• Unpack: decodifica stringhe secondo il formato richiesto– Es: ($a,$b)=unpack(“ll”, “abcdefgh”);

Scambio di messaggiSimile alle FIFO (pipe con nome), solo i dati possono essere dei record

contenenti variabili di tipi diversi.

msgget(KEY,FLAG) definisce una coda di messaggi e ne restituisce l’ID

msgrcv(ID,VAR,SIZE,TYPE,FLAGS) riceve un messaggio dalla coda ID in VAR con lunghezza massima SIZE. VAR

inizia con il tipo di messaggio ($type,$msg)=unpack(‘ll’,$rcv);

msgsnd(ID,MSG,FLAGS) manda il messaggio MSG alla coda ID. MSG deve iniziare con un long che rappresenta il tipo di messaggio

pack(“l”,$type);

msgctl(ID,CMD,ARG) controllo coda di messaggi

Tipo di messaggio: 0 primo messaggio sulla lista

>0 primo messaggio di quel tipo

<0 primo messaggio con il minimo tipo

Messaggi

use IPC::SysV qw(IPC_PRIVATE IPC_RMID IPC_CREAT S_IRWXU);

my $id = msgget(IPC_PRIVATE, IPC_CREAT | S_IRWXU);

my $sent = "message";

my $type = 1234;

my $rcvd;

my $type_rcvd;

Messaggi

if (defined $id) { if (msgsnd($id, pack("l", $type_sent), $sent, 0)) { if (msgrcv($id, $rcvd, 60, 0, 0)) {

($type_rcvd, $rcvd) = unpack("ll", $rcvd); if ($rcvd eq $sent) { print "okay\n"; }

else { print "not okay\n"; } } else { die "# msgrcv failed\n"; } }

else { die "# msgsnd failed\n"; }

msgctl($id, IPC_RMID, 0) || die "msgctl failed\n"; } else { die "# msgget failed\n"; }

Socket in Perl

Programmazione Client-Server

Si utilizzano i socket di Internet per far comunicare due processi

Server ascolta sul socket in attesa di un collegamento

da parte di un client

Client chiama il server, il server risponde e

i processi possono comunicare

Socket in Perl

Inizializzazione di un socket (CLIENT e SERVER)Sia il client che il server usano la chiamata socket per creare un socket e associarlo a un filehandle.

use Socket;

socket(SH, PF_INET, SOCK_STREAM, getprotobyname(’tcp’)) || die $!;

socket(SH2, PF_INET, SOCK_DGRAM, getprotobyname(’udp’)) || die $!;

I socket con un indirizzo del dominio Unix usano PF_UNIX anziché PF_INET.

Socket in Perl

CLIENT

Dal lato client, dopo l’inizializzazione (con la chiamata di sistema socket)

bisogna realizzare la connessione con un server su una porta e un

host particolare, usando la chiamata connect.

Una volta stabilita la connessione, possiamo leggere dal socket o scrivere

sul socket.

Al termine il socket va chiuso con shutdown o close.

Socket in Perl

my $dest = sockaddr_in(80, inet_aton(’www.units.it’));

connect (SH, $dest) || die $!;

$data="Ciao";

send(FH, $data);

select(FH);

print "$data";

recv(FH, $buffer);

$input=<FH>;

close(FH);

Socket in Perl

Dopo aver creato un socket con socket, è necessario che

un’applicazione server passi attraverso le seguenti operazioni

per ricevere la connessione di rete:

1) associa il socket a un numero di porta e indirizzo della macchina;

2) mettersi in ascolto di connessioni di client entranti sulla porta;

3) accettare una richiesta di client e assegnare la connessione al filehandle specificato.

Socket in Perl

my $proto=getprotobyname(’tcp’);

socket(FH, PF_INET, SOCK_STREAM, $proto) || die $!;

my $sin = sockaddr_in(80, INADDR_ANY);

bind(FH, $sin) || die $!;

listen(FH, $length);

accept(NEW_FH, FH) || die $!;

# Ora il server comunica col client usando NEW_FH

#!/usr/bin/perl# file server.pl#use Socket;use Carp;#$EOL = "\015\012";sub logmsg { print "$0 $$: @_ at ", scalar localtime, "\n" }my $port = shift || 2345;my $proto = getprotobyname('tcp');$port = $1 if $port =~ /(\d+)/;socket(Server, PF_INET, SOCK_STREAM, $proto) || die "socket: $!";setsockopt(Server, SOL_SOCKET, SO_REUSEADDR, pack("l", 1)) || die ;bind(Server, sockaddr_in($port, INADDR_ANY)) || die "bind: $!";listen(Server,SOMAXCONN) || die "listen: $!";logmsg "server avviato alla porta $port";my $paddr;$SIG{CHLD} = \&REAPER;for ( ; $paddr = accept(Client,Server); close Client) { my($port,$iaddr) = sockaddr_in($paddr); my $name = gethostbyaddr($iaddr,AF_INET); logmsg "Connessione da $name [", inet_ntoa($iaddr), "], porta

$port"; print Client "Salve $name, sono le ", scalar localtime, "\n";}

#!/usr/bin/perl –w# file client.pl#use Socket;my ($remote,$port, $iaddr, $paddr, $proto, $line);$remote = shift || 'localhost';$port = shift || 2345; # random portif ($port =~ /\D/) { $port = getservbyname($port, 'tcp') }die "No port" unless $port;$iaddr = inet_aton($remote) || die "no host: $remote";$paddr = sockaddr_in($port, $iaddr);$proto = getprotobyname('tcp');socket(SOCK, PF_INET, SOCK_STREAM, $proto) || die "socket:$!";connect(SOCK, $paddr) || die "connect: $!";while (defined($line = <SOCK>)) { print $line;}close (SOCK) || die "close: $!";exit;

#!/usr/bin/perl# file webserver.pl#use Socket;my ($port, $proto, $paddr, $name, $iaddr);$port = 80;$proto = getprotobyname('tcp');socket(SOCK, PF_INET, SOCK_STREAM, $proto) || die "socket: $!"; setsockopt(SOCK, SOL_SOCKET, SO_REUSEADDR, 1) || die "setsockopt: $!";bind(SOCK, sockaddr_in($port, INADDR_ANY)) || die "bind: $!";listen(SOCK, SOMAXCONN) || die "listen: $!";while(1) { $paddr = accept(CLIENT, SOCK); ($port, $iaddr) = sockaddr_in($paddr); $name = gethostbyaddr($iaddr, AF_INET); print STDERR "Chiamata da [", inet_ntoa($iaddr), "]\n"; $messaggio = <CLIENT>; ($richiesta, $filename) = split(/\s+/, $messaggio); if ($richiesta =~ /^GET/) { open(INP, $filename) || print CLIENT "Errore\n"; while($line = <INP>) { print CLIENT $line; } } close(CLIENT);}

#!/usr/bin/perl –w# file: webclient.pluse Socket;my ($remote, $port, $proto, $iaddr, $paddr, $line, $richiesta, $len,

$written);if ($#ARGV != 1) { print STDERR "USO: $0 host file\n"; exit(1);}$remote = $ARGV[0];$port = "www"; # porta standard per il WWWif ($port =~ /\D/) { $port = getservbyname($port, 'tcp'); } die

"No port" unless $port;$iaddr = inet_aton($remote) or die "no host: $remote\n";$paddr = sockaddr_in($port, $iaddr);$proto = getprotobyname('tcp');socket(SOCK, PF_INET, SOCK_STREAM, $proto) || die "socket $!";connect(SOCK, $paddr) || die "connect: $!";$richiesta = "GET /" . $ARGV[1] . "\n";$written = syswrite(SOCK, $richiesta, length($richiesta));die "System write error: $!\n“ unless defined $written; while($line = <SOCK>) { print $line; } close(SOCK) or die "close: $!";exit;

Quarta parte.

Elenco delle funzioni principali.

• Elaborazione di array• pop, push, shift, splice, unshift

• Elaborazione di liste• grep, join, map, qw//, reverse, sort, unpack

• Elaborazione di hash• delete, each, exists, keys, values

• Input e output• binmode, close, closedir, dbmclose, dbmopen, die,• eof, fileno, flock, format, getc, print, printf,• read, readdir, rewinddir, seek, seekdir, select,• syscall, sysread, sysseek, syswrite, tell, relldir,• truncate, warn, write

• Dati a lunghezza fissa e record• pack, read, syscall, sysread, syswrite, unpack, vec

• Filehandle, file e directory• chdir,chmod, chown, chroot, fcntl, glob,ioctl, link,• lstat,mkdir, open,opendir, readlink, rename, rmdir,• stat, symlink, sysopen, umask, unlink, utime

• Controllo del flusso di programma• caller, continue, die, do, dump, eval, exit, goto,• last, next, redo, return, sub, wantarray

• Visibilità• caller, import, local, my, package, use

• Varie• defined, dump, eval, formline, local, my, prototype,• reset, scalar, undef, wantarray

• Processi e gruppi di processi• alarm, exec, fork, getprrp, getpid, getpriority,• kill, pipe, qx//, setpgrp, setpriority, sleep, system,• times, wait, waitpid

• Moduli di libreria• do, import, no, package, require, use

• Classi e oggetti• bless, dbmclose, dbmopen, package, ref, tie, tied,• untied, use

• Accesso di basso livello ai socket• accept, bind, connect, getpeername, getsockname,• getsockopt, listen, recv, send, setsockopt, shutdown,• socket, socketpair

• Comunicazione interprocesso System V• msgctl, msgget, msgrcv, msgsnd, semctl, semget,• semop, shmctl, shmget, shmread, shmwrite

• Prelievo delle informazioni di utente e di gruppo• endgrent, endhostent, endnetent, endpwent, getgrent,• getgrgid, getgrnam, getlogin, getpwent, getpwnam,• getpwuid, setgrent, setpwent

• Prelievo delle informazioni di rete• endprotoent, endservent, gethostbyaddr, gethostbyname,• gethostent, getnetbyaddr, getnetbyname,• getnetent, getprotobyname, getprotobynumber, getprotoent,• getservbyname, getservbyport, getservent,• sethostent, setetent, setprotoent, setservent

• Data e ora• gmtime, localtime, time, times