POD2-IT

 view release on metacpan or  search on metacpan

IT/perlfunc.pod  view on Meta::CPAN

=item Funzioni per filehandle, file o directory
X<file> X<filehandle> X<directory> X<pipe> X<link> X<symlink>

C<-I<X>>, C<chdir>, C<chmod>, C<chown>, C<chroot>, C<fcntl>, C<glob>,
C<ioctl>, C<link>, C<lstat>, C<mkdir>, C<open>, C<opendir>,
C<readlink>, C<rename>, C<rmdir>, C<stat>, C<symlink>, C<sysopen>,
C<umask>, C<unlink>, C<utime>

=item Parole chiave relative al controllo di flusso del vostro programma Perl
X<controllo di flusso>

C<caller>, C<continue>, C<die>, C<do>, C<dump>, C<eval>, C<exit>,
C<goto>, C<last>, C<next>, C<redo>, C<return>, C<sub>, C<wantarray>

=item Parole chiave relative alla visibilitE<agrave> delle variabili (scoping)

C<caller>, C<import>, C<local>, C<my>, C<our>, C<package>, C<use>

=item Funzioni varie

C<defined>, C<dump>, C<eval>, C<formline>, C<local>, C<my>, C<our>, C<reset>,
C<scalar>, C<undef>, C<wantarray>

=item Funzioni per processi e gruppi di processi
X<processo> X<pid> X<id di processo>

C<alarm>, C<exec>, C<fork>, C<getpgrp>, C<getppid>, C<getpriority>, C<kill>,
C<pipe>, C<qx/STRINGA/>, C<setpgrp>, C<setpriority>, C<sleep>, C<system>,
C<times>, C<wait>, C<waitpid>

=item Parole chiave relative ai moduli perl
X<modulo>

C<do>, C<import>, C<no>, C<package>, C<require>, C<use>

=item Parole chiave relative alle classi e al campo dell'orientamento agli oggetti
X<oggetto> X<classe> X<package>

C<bless>, C<dbmclose>, C<dbmopen>, C<package>, C<ref>, C<tie>, C<tied>,
C<untie>, C<use>

=item Funzioni di basso livello per i socket
X<socket> X<sock>

C<accept>, C<bind>, C<connect>, C<getpeername>, C<getsockname>,
C<getsockopt>, C<listen>, C<recv>, C<send>, C<setsockopt>, C<shutdown>,
C<socket>, C<socketpair>

=item Funzioni di comunicazione tra processi di System V
X<IPC> X<System V> X<semaforo> X<memoria condivisa> X<memoria> X<messaggio>

C<msgctl>, C<msgget>, C<msgrcv>, C<msgsnd>, C<semctl>, C<semget>, C<semop>,
C<shmctl>, C<shmget>, C<shmread>, C<shmwrite>

=item Recupero delle informazioni dell'utente e del gruppo
X<user> X<group> X<password> X<uid> X<gid> X<passwd> X</etc/passwd>

C<endgrent>, C<endhostent>, C<endnetent>, C<endpwent>, C<getgrent>,
C<getgrgid>, C<getgrnam>, C<getlogin>, C<getpwent>, C<getpwnam>,
C<getpwuid>, C<setgrent>, C<setpwent>

=item Recupero delle informazioni di rete
X<rete> X<protocollo> X<host> X<nome dell'host> X<IP> X<indirizzo> X<servizio>

C<endprotoent>, C<endservent>, C<gethostbyaddr>, C<gethostbyname>,
C<gethostent>, C<getnetbyaddr>, C<getnetbyname>, C<getnetent>,
C<getprotobyname>, C<getprotobynumber>, C<getprotoent>,
C<getservbyname>, C<getservbyport>, C<getservent>, C<sethostent>,
C<setnetent>, C<setprotoent>, C<setservent>

=item Funzioni relative al tempo
X<tempo> X<data>

C<gmtime>, C<localtime>, C<time>, C<times>

=item Nuove funzioni in perl5
X<perl5>

C<abs>, C<bless>, C<chomp>, C<chr>, C<exists>, C<formline>, C<glob>,
C<import>, C<lc>, C<lcfirst>, C<map>, C<my>, C<no>, C<our>, C<prototype>,
C<qx>, C<qw>, C<readline>, C<readpipe>, C<ref>, C<sub*>, C<sysopen>, C<tie>,
C<tied>, C<uc>, C<ucfirst>, C<untie>, C<use>

* - C<sub> era una parola chiave in perl4, ma in perl5 E<egrave> un operatore, 
che puE<ograve> essere usato nelle espressioni.

=item Funzioni obsolete in perl5

C<dbmclose>, C<dbmopen>

=back

=head2 PortabilitE<agrave>
X<portabilita`> X<Unix> X<portabile>

Perl E<egrave> nato su Unix e dunque puE<ograve> accedere a tutte le normali 
chiamate di sistema Unix. In ambienti non-Unix, le funzionalitE<agrave> di 
alcune di queste chiamate potrebbe non essere disponibile, oppure i dettagli 
potrebbero essere un po' diversi. Le funzioni Perl influenzate da questo aspetto 
sono:

C<-X>, C<binmode>, C<chmod>, C<chown>, C<chroot>, C<crypt>,
C<dbmclose>, C<dbmopen>, C<dump>, C<endgrent>, C<endhostent>,
C<endnetent>, C<endprotoent>, C<endpwent>, C<endservent>, C<exec>,
C<fcntl>, C<flock>, C<fork>, C<getgrent>, C<getgrgid>, C<gethostbyname>,
C<gethostent>, C<getlogin>, C<getnetbyaddr>, C<getnetbyname>, C<getnetent>,
C<getppid>, C<getpgrp>, C<getpriority>, C<getprotobynumber>,
C<getprotoent>, C<getpwent>, C<getpwnam>, C<getpwuid>,
C<getservbyport>, C<getservent>, C<getsockopt>, C<glob>, C<ioctl>,
C<kill>, C<link>, C<lstat>, C<msgctl>, C<msgget>, C<msgrcv>,
C<msgsnd>, C<open>, C<pipe>, C<readlink>, C<rename>, C<select>, C<semctl>,
C<semget>, C<semop>, C<setgrent>, C<sethostent>, C<setnetent>,
C<setpgrp>, C<setpriority>, C<setprotoent>, C<setpwent>,
C<setservent>, C<setsockopt>, C<shmctl>, C<shmget>, C<shmread>,
C<shmwrite>, C<socket>, C<socketpair>,
C<stat>, C<symlink>, C<syscall>, C<sysopen>, C<system>,
C<times>, C<truncate>, C<umask>, C<unlink>,
C<utime>, C<wait>, C<waitpid>

Per maggiori informazioni riguardanti la portabilitE<agrave> di queste 
funzioni, consultate L<perlport> ed altra documentazione disponibile 
specifica per una data piattaforma.

=head2 Elenco delle funzioni Perl in ordine alfabetico

=over 8

=item -X FILEHANDLE
X<-r>X<-w>X<-x>X<-o>X<-R>X<-W>X<-X>X<-O>X<-e>X<-z>X<-s>X<-f>X<-d>X<-l>X<-p>
X<-S>X<-b>X<-c>X<-t>X<-u>X<-g>X<-k>X<-T>X<-B>X<-M>X<-A>X<-C>

=item -X EXPR

=item -X

Un test sul file, dove X E<egrave> una delle lettere elencate di seguito. Questo
operatore unario opera su un argomento, o un nome di file o un
filehandle, e controlla il file associato per verificare la veritE<agrave> di
una condizione. Se si omette l'argomento, utilizza il valore corrente di
C<$_>; fa eccezione C<-t>, che utilizza STDIN.
A meno di indicazione contraria, restituisce C<1> per indicare la veritE<agrave>
della condizione verificata, e C<''> in caso di falsitE<agrave>, mentre
restituisce un valore non definito se il file non esiste. A dispetto
della stranezza dei nomi, valgono le stesse regole di precedenza di ogni
altro operatore unario, e l'argomento puE<ograve> essere racchiuso fra parentesi
come per qualsiasi altro operatore. L'operatore puE<ograve> essere uno qualsiasi
fra quelli seguenti:

    -r	Il file e` leggibile da parte del uid/gid effettivo.
    -w	Il file e` scrivibile da parte del uid/gid effettivo.
    -x	Il file e` eseguibile da parte del uid/gid effettivo.
    -o	Il file appartiene al uid effettivo.

    -R	Il file e` leggibile da parte del uid/gid reale.
    -W	Il file e` scrivibile da parte del uid/gid reale.
    -X	Il file e` eseguibile da parte del uid/gid reale.
    -O	Il file appartiene al uid reale.

    -e	Il file esiste.
    -z	Il file ha dimensione zero (e` vuoto).
    -s	Il file ha dimensione diversa da zero (restituisce la dimensione in byte).

    -f	Il file e` un file vero e proprio [non una directory ma un link, NdT]
    -d	Il file e` una directory.
    -l	Il file e` un link simbolico.
    -p	Il file e` una named pipe (FIFO), o la Filehandle e` una pipe.
    -S	Il file e` un socket.
    -b	Il file e` un file speciale per una periferica a blocchi.

IT/perlfunc.pod  view on Meta::CPAN

Per l'operazione del coseno inverso, potete utilizzare la funzione 
C<Math::Trig::acos()>, oppure questa relazione:

    sub acos { atan2( sqrt(1 - $_[0] * $_[0]), $_[0] ) }

=item crypt TESTOINCHIARO,SEME
X<crypt> X<digest> X<hash> X<salt> X<plaintext> X<password>
X<decrypt> X<cryptography> X<passwd>

Crea una stringa digest [riassunto, NdT] proprio come fa la funzione
crypt(3) nella libreria C (assumendo che ce ne abbiate davvero una, che
non sia stata estirpata quale potenziale armamento).

crypt() E<egrave> una funzione non invertibile. TESTOINCHIARO e SEME sono
convertiti in una breve stringa, chiamata digest, che viene restituita.
I medesimi TESTOINCHIARO e SEME restituiranno sempre la stessa stringa,
ma non c'E<egrave> nessun modo (conosciuto) per ottenere il TESTOINCHIARO
dall'hash. Piccoli cambiamenti nel TESTOINCHIARO o nel SEME ha come
risultato dei grandi cambiamenti nel digest.

Non c'E<egrave> una funzione di decifratura. Questa funzione non E<egrave>
per nulla utile alla crittografia (per questa cosa, date un'occhiata ai moduli
F<Crypt> sul vostro mirror CPAN piE<ugrave> vicino) e il nome "crypt" [cripta, NdT]
E<egrave> un po' un termine improprio. Il suo uso principale E<Egrave> invece
quello di controllare se due parti di testo sono le stesse senza dover
trasmettere o immagazzinare il testo stesso. Un esempio E<egrave> controllare
se viene fornita una password corretta. E<Egrave> il digest della password ad
essere immagazzinato e non la password stessa. L'utente digita una password
che viene sottoposta a crypt() con il medesimo digest memorizzato quale seme.
Se i due digest corrispondono, la password E<egrave> corretta.

Quando effettuate la verifica di una stringa digest esistente, dovreste usare il 
digest come seme (come C<crypt($chiaro, $digest) eq $digest>). La parte 
SEME usata per creare il digest E<egrave> visibile come parte del digest.
Questo assicura che crypt() calcolerE<agrave> l'hash della nuova stringa
con lo stesso seme del digest. Questo fa sE<igrave> che il vostro codice funzioni
sia con la L<crypt|/crypt> standard che con implementazioni piE<ugrave> esotiche. 
In altre parole, non presumete nulla sulla stringa restituita, o su 
quanti byte siano siano significativi nel digest.

Tradizionalmente, il risultato E<egrave> una stringa di 13 byte: i 
primi due sono il seme, e sono seguiti da 11 byte appartenenti 
all'insieme C<[./0-9A-Za-z]>, e solo i primi otto byte della stringa 
digest sono significativi; tuttavia, schemi di hashing alternativi 
(come MD5), schemi di sicurezza di livello piE<ugrave> elevato 
(come C2) ed implementazioni su piattaforme non-UNIX, possono 
generare stringhe diverse.

Quando scegliete un nuovo seme, create una stringa casuale di due 
caratteri, i quali devono appartenere all'insieme C<[./0-9A-Za-z]> 
(come C<join '', ('.', '/', 0..9, 'A'..'Z', 'a'..'z')[rand 64, rand 64]>). 
Questo insieme di caratteri E<egrave> solo una raccomandazione; i 
caratteri permessi nel seme dipendono esclusivamente dalla vostra 
libreria crypt di sistema, e il Perl non puE<ograve> limitare i semi 
accettati da C<crypt()>.

Ecco un esempio che ci assicura che chiunque faccia girare questo 
programma conosca la propria password:

    $pwd = (getpwuid($<))[1];

    system "stty -echo";
    print "Password: ";
    chomp($parola = <STDIN>);
    print "\n";
    system "stty echo";

    if (crypt($parola, $pwd) ne $pwd) {
        die "Spiacente...\n";
    } else {
        print "ok\n";
    }

Chiaramente, scrivere la vostra password a chiunque ve la richieda 
non E<egrave> saggio.

La funzione L<crypt|/crypt> non E<egrave> adatta per calcolare il
valore di hash per grandi quantitE<agrave> di dati, non del tutto
almeno, perchE<eacute> non potete ottenere le vostre informazioni
di nuovo in chiaro. Date un'occhiata al modulo L<Digest> per ulteriori
robusti algoritmi.

Se usate crypt() su una stringa Unicode (che I<potenzialmente>
contiene caratteri con codice superiore a 255), Perl cerca di dare
un senso alla situazione cercando di riportare (una copia de) la
stringa ad una stringa a otto bit prima di chiamare crypt() (su
quella copia). Se ciE<ograve> funziona, bene. Altrimenti, crypt()
termina con C<Wide character in crypt> [crypt su carattere esteso, NdT]

=item dbmclose HASH
X<dbmclose>

[Questa funzione E<egrave> stata ampiamente soppiantata dalla funzione C<untie>].

Rompe il legame tra un file DBM ed un hash.

=item dbmopen HASH,NOMEDB,MASCHERA
X<dbmopen> X<dbm> X<ndbm> X<sdbm> X<gdbm>

[Questa funzione E<egrave> stata ampiamente soppiantata dalla 
funzione C<tie>].

Questa funzione effettua un legame tra un file di tipo dbm(3), 
ndbm(3), sdbm(3), gdbm(3) oppure Berkeley DB in un hash. HASH 
E<egrave> il nome dell'hash. (Diversamente dalla normale C<open>, 
il primo argomento I<non> E<egrave> un filehandle, anche se ci 
assomiglia). NOMEDB E<egrave> il nome del database (senza 
l'estensione F<.dir> o F<.pag>, se presente). Se il database non 
esiste, viene creato con una protezione specificata da MASCHERA 
(come modificato dalla funzione C<umask>). Se il vostro sistema 
supporta solo le vecchie funzioni DBM, nel vostro programma 
potete effettuare solo una C<dbmopen>. In vecchie versioni di 
Perl, se il vostro sistema non possedeva nE<eacute> DBM nE<eacute> 
ndbm, chiamare C<dbmopen> produceva un errore bloccante; ora 
ciE<ograve> ricade su sdbm(3).

Se non avete accesso in scrittura sul file DBM, potete solo 
leggere i valori dell'hash e non impostarli. Se volete testare la 
possibilitE<agrave> di scrivere, usate o i test sui file oppure 
tentate di impostare l'elemento di un hash fittizio all'interno di 

IT/perlfunc.pod  view on Meta::CPAN

quanti a capo sono inseriti nella DESCRIZIONE. 
Questo significa che i token C<~> e C<~~> tratteranno l'intera 
DESCRIZIONE come una singola linea. PerciE<ograve> potreste  
avere la necessitE<agrave> di usare formline multipli per 
implementare un singolo record di formato, proprio come il 
compilatore di formato.

Prestate attenzione se mettete tra virgolette doppie alla 
descrizione, visto che un carattere C<@> puE<ograve> 
assumere il significato di inizio del un nome di array. 
C<formline> restituisce sempre vero. Consultate L<perlform> 
per altri esempi.

=item getc FILEHANDLE
X<getc> X<getchar>

=item getc

Restituisce il prossimo carattere dal file di input associato 
con il FILEHANDLE, oppure il valore indefinito alla fine del 
file o se c'E<egrave> stato un errore (in quest'ultimo caso 
viene impostato C<$!>). Se FILEHANDLE viene omesso, legge da 
STDIN. Questo non E<egrave> particolarmente efficiente. 
Comunque, non puE<ograve> essere usata da se stessa per 
prelevare dei singoli caratteri senza aspettare che l'utente 
abbia premuto invio. Per questo, provate piuttosto qualcosa 
come:

    if ($STILE_BSD) {
	system "stty cbreak </dev/tty >/dev/tty 2>&1";
    }
    else {
	system "stty", '-icanon', 'eol', "\001";
    }

    $tasto = getc(STDIN);

    if ($STILE_BSD) {
	system "stty -cbreak </dev/tty >/dev/tty 2>&1";
    }
    else {
	system "stty", 'icanon', 'eol', '^@'; # null ASCII
    }
    print "\n";

Determinare come deve essere impostato $STILE_BSD viene 
lasciato come esercizio al lettore.

La funzione C<POSIX::getattr> puE<ograve> fare questo in 
maniera piE<ugrave> portabile su sistemi che vogliono farsi 
passare per essere conformi a POSIX. Date un'occhiata anche 
al modulo C<Term::ReadKey>, dal piE<ugrave> vicino sito 
CPAN; dettagli su CPAN possono essere trovati su 
L<perlmodlib/CPAN>.

=item getlogin
X<getlogin> X<login>

Implementa la funzione della libreria C che ha lo stesso nome, 
la quale su molti sistemi restituisce il login corrente da 
F</etc/utmp>, se presente. Se non presente, usate C<getpwuid>.

    $login = getlogin || getpwuid($<) || "Kilroy";

Non prendete in considerazione C<getlogin> per l'autenticazione: 
non E<egrave> sicura quanto C<getpwuid>. 

=item getpeername SOCKET
X<getpeername> X<peer>

Restituisce l'indirizzo compattato (sockaddr) dell'altro capo della 
connessione SOCKET.

    use Socket;
    $suosockaddr         = getpeername(SOCK);
    ($porta, $indirizzo) = sockaddr_in($suosockaddr);
    $suohostname         = gethostbyaddr($indirizzo, AF_INET);
    $suoindirizzo        = inet_ntoa($indirizzo);

=item getpgrp PID
X<getpgrp> X<gruppo>

Restituisce il gruppo del processo corrente per il PID specificato.
Usate un PID di C<0> per ottenere il gruppo del processo corrente 
per il processo corrente. SolleverE<agrave> un'eccezione se usato 
su elaboratori che non implementano getpgrp(2). Se PID viene 
omesso, restituisce il gruppo del processo del processo corrente. 
Va notato che la versione POSIX di C<getpgrp> non accetta un PID 
come argomento, dunque solo C<PID==0> E<egrave> davvero portabile.

=item getppid
X<getppid> X<genitore> X<pid>

Restituisce l'id del processo genitore.

Nota per gli utenti Linux: le funzioni C C<getpid()> e C<getppid()>
implementate in Linux, restituiscono valori differenti se chiamate da
thread diversi. Per mantenere la portabilitE<agrave>, questo
comportamento non si riflette nella funzione Perl C<getppid()>, che
restituisce lo stesso valore anche se chiamata da thread diversi. Per
richiamare la funzione C<getppid()> di sistema si puE<ograve> utilizzare
il modulo CPAN C<Linux::Pid>.

=item getpriority QUALE,CHI
X<getpriority> X<priorita`> X<nice>

Restituisce la prioritE<agrave> corrente per un processo, un gruppo di 
processi, o un utente. (Consultate L<getpriority(2)>). SolleverE<agrave> 
un'eccezione bloccante se usata in una macchina che non implementa 
getpriority(2).

=item getpwnam NOME
X<getpwnam> X<getgrnam> X<gethostbyname> X<getnetbyname> X<getprotobyname>
X<getpwuid> X<getgrgid> X<getservbyname> X<gethostbyaddr> X<getnetbyaddr>
X<getprotobynumber> X<getservbyport> X<getpwent> X<getgrent> X<gethostent>
X<getnetent> X<getprotoent> X<getservent> X<setpwent> X<setgrent> X<sethostent>
X<setnetent> X<setprotoent> X<setservent> X<endpwent> X<endgrent> X<endhostent>
X<endnetent> X<endprotoent> X<endservent>

=item getgrnam NOME

=item gethostbyname NOME

=item getnetbyname NOME

=item getprotobyname NOME

=item getpwuid UID

=item getgrgid GID

=item getservbyname NOME,PROTO

=item gethostbyaddr INDIR,TIPOINDIR

=item getnetbyaddr INDIR,TIPOINDIR

=item getprotobynumber NUMERO

=item getservbyport PORTA,PROTO

=item getpwent

=item getgrent

=item gethostent

=item getnetent

=item getprotoent

=item getservent

=item setpwent

=item setgrent

=item sethostent RIMANI_APERTO

=item setnetent RIMANI_APERTO

=item setprotoent RIMANI_APERTO

=item setservent RIMANI_APERTO

=item endpwent

=item endgrent

=item endhostent

=item endnetent

=item endprotoent

=item endservent

Queste routine compiono le stesse funzioni delle loro controparti 
nella libreria di sistema. In un contesto di lista, restituiscono 
i valori dalle varie routine di get [ottenere, NdT], come segue:

    ($nome,$passwd,$uid,$gid,
       $quota,$commento,$gcos,$dir,$shell,$scadenza) = getpw*
    ($nome,$passwd,$gid,$members) = getgr*
    ($nome,$alias,$tipoind,$lungh,@indirizzi) = gethost*
    ($nome,$alias,$tipoind,$net) = getnet*
    ($nome,$alias,$proto) = getproto*
    ($nome,$alias,$porta,$proto) = getserv*

(Se la voce non esiste, otterrete una lista nulla).

L'esatto significato del campo $gcos varia ma di solito esso contiene 
il vero nome dell'utente (rispetto al nome del login) e altre 
informazioni pertinente all'utente. Fate attenzione, comunque, che su 
molti sistemi gli utenti sono in grado di cambiare queste informazioni 
e dunque ciE<ograve> non puE<ograve> essere verificato e dunque $gcos 
E<egrave> un dato potenzialmente dannoso (taint) (consultate L<perlsec>). 
$passwd e $shell, la password cifrata dell'utente e la shell di login 
sono anch'esse dei dati potenzialmente dannosi per il medesimo motivo.

In contesto scalare, otterrete il nome a meno che la funzione non sia 
ottenuta con una ricerca per nome, nel qual caso otterrete l'altra cosa, 
qualunque essa sia (se l'elemento non esiste, otterrete il valore 
indefinito). Per esempio:

    $uid   = getpwnam($nome);
    $nome  = getpwuid($num);
    $nome  = getpwent();
    $gid   = getgrnam($nome);
    $nome  = getgrgid($num;
    $nome  = getgrent();
    #ecc.

In I<getpw*()>, i campi $quota, $commento e $scadenza sono casi 
speciali nel senso che in molti sistemi non sono supportati. Se 
$quota non E<egrave> supportato, E<egrave> uno scalare vuoto. 
Se E<egrave> supportato, di solito codifica il valore della quota 
del disco. Se $commento non E<egrave> supportato, E<egrave> uno 
scalare vuoto. Se E<egrave> supportato di solito codifica dei 
commenti amministrativi sull'utente. In alcuni sistemi il campo 
$quota puE<ograve> essere $cambiamento oppure $eta, campi che 
hanno a che fare con l'obsolescenza delle password. In alcuni 
sistemi, il campo $commento puE<ograve> essere $classe. Il campo 
$scadenza, se presente, codifica il periodo di scadenza dell'account 
o della password. Per la disponibilitE<agrave> e l'esatto significato 
di questi campi nel vostro sistema, consultate la documentazione di 
getpwnam(3) e il file F<pwd.h>. Potete anche scoprire dall'interno 
del Perl che significato hanno i vostri $quota e $commento e se 
possedete il campo $expire, tramite l'utilizzo del modulo C<Config> e 
i valori C<d_pwquota>, C<d_pwage>, C<d_pwchange>, C<d_pwcomment> e 
C<d_pwexpire>. I file con le password shadow sono supportati solo se 
l'azienda produttrice di software che vi fornisce li ha implementati 
in quel modo intuitivo che, chiamando le routine della libreria C 
usuale, ottiene le versioni shadow se siete in esecuzione con i 
privilegi o se esistono le funzioni shadow(3) come si trovano in 
System V (questo include Solaris e Linux). Quei sistemi che 
implementano un'infrastruttura proprietaria per le password shadow 
E<egrave> improbabile che siano supportati.

Il valore di $members restituito da I<getgr*()> E<egrave> una lista separata da spazi dei nomi 
di login dei membri del gruppo.

Per le funzioni I<gethost*()>, se la variabile C<h_errno> E<egrave> supportata in C, vi sarE<agrave> 
restituita attraverso C<$?> se la chiamata di funzione fallisce. Il valore C<@addrs> restituito da 
una chiamata che ha avuto successo E<egrave> una lista di indirizzi grezza, restituita dalla 
corrispondente chiamata della libreria di sistema. In ambito Internet, ogni indirizzo E<egrave> 
lungo 4 byte e potete effettuare unpack su esso scrivendo qualcosa come:

    ($a,$b,$c,$d) = unpack('C4',$ind[0]);

La libreria Socket rende questo un po' piE<ugrave> facile:

    use Socket;
    $indint = inet_aton("127.1"); # o qualsiasi indirizzo
    $nome  = gethostbyaddr($indint, AF_INET);

    # oppure andando nell'altro verso
    $strind = inet_ntoa($indint);

Se siete stanchi di tenere a mente quali valori corrispondono a quali elementi della lista 
restituita, vengono fornite delle interfacce per nome nei moduli standard: C<File::stat>, 
C<Net::hostent>, C<Net::netent>, C<Net::protoent>, C<Net::servent>, C<Time::gmtime>, C<Time::localtime> 
e C<User::grent>. Queste si sovrappongono alle normali funzioni interne, fornendo versioni che 
restituiscono oggetti con i nomi appropriati per ogni campo. Per esempio:

   use File::stat;
   use User::pwent;