danny block notes

giovedì, 16 aprile 2009

Pulizia repository Ubuntu per liberare spazio dal disco

Filed under: linux — danny @ 2:04 pm

Per liberare diverso spazio dall’ hard disk (soprattutto per chi effettua numerose installazioni/update attraverso i repos) esistono i seguenti comandi da eseguire in sequenza :

1. “sudo apt-get autoremove”

2. “sudo apt-get clean”

Il primo rimuove tutte le dipendenze inutilizzate o ridondanti.

Il secondo svuota la cache.

Per vedere al volo lo spazio liberato è possibile utilizzare prima e dopo il comando “df – h”.

domenica, 8 giugno 2008

Installare VMWare Player in Ubuntu 8.04 Hardy Heron (aggiornato)

Testato con la versione versione 2.0.3-80004 di VMWare Player. Per la versione 2.0.4 leggere in fondo.

  1. Installiamo questi pacchetti con il comando :
    sudo aptitude -P install build-essential linux-kernel-headers linux-kernel-devel
  2. Creiamo e posizioniamoci in una cartella di lavoro che alla fine potremo eliminare (per esempio sulla scrivania) ;
  3. Scaricate nella cartella il pacchetto VMware-player-2.0.3-80004.i386.tar.gz direttamente dal sito vmware.com ;
  4. scompattiamo l’archivio del player e lanciamo lo script di installazione :
    tar -xzvf VMware-player-2.0.3-80004.i386.tar.gz
    cd vmware-player-distrib/
    sudo ./vmware-install.pl
  5. premere ad ogni richiesta INVIO in modo da accettare la configurazione di default.
  6. ignorare il messaggio di errore ricevuto, risolveremo il problema con la seguente patch :
    wget http://xmi.pl/kernel/vmware-any-any-update-116.tgz
    tar -xzvf vmware-any-any-update-116.tgz
    cd vmware-any-any-update116/
    sudo ./runme.pl
  7. continuerà l’installazione e come al solito premere INVIO per installare con le opzioni di default.
  8. se tutto è andato a buon fine sarà possibile lanciare vmware player con il comando
    vmplayer

AGGIORNAMENTO :

eseguendo gli aggiornamenti automatici di ubuntu, in particolare gli update che riguardano il kernel 2.6.24-17( o 18), il player molto probabilmente non funzionerà più.

Per rimediare, un modo veloce è quello di disinstallare vmware e reinstallarlo.

Qui di seguito sono riportare 2 diverse procedure a seconda se si vuole reinstallare la versione 2.0.3 ola più recente 2.0.4 .

Disinstallazione e re-installazione di vmware player 2.0.3 :

  1. per disinstallare basta lanciare da shell il comando
    sudo vmware-uninstall.pl
  2. ripetere l’installazione partendo dal punto 2 della guida iniziale.

Disinstallazione e re-installazione di vmware player 2.0.4 :

  1. per disinstallare basta lanciare da shell il comando
    sudo vmware-uninstall.pl
  2. creiamo e posizioniamoci in una cartella di lavoro che alla fine potremo eliminare (per esempio sulla scrivania) ;
  3. scaricate nella cartella il pacchetto VMware-player-2.0.4-93057.i386 direttamente dal sito vmware.com ;
  4. scompattiamo l’archivio del player e lanciamo lo script di installazione :
    tar -xzvf VMware-player-2.0.4-93057.i386.tar.gz
    cd vmware-player-distrib/
    sudo ./vmware-install.pl
  5. premere ad ogni richiesta INVIO in modo da accettare la configurazione di default.
  6. se tutto è andato a buon fine sarà possibile lanciare vmware player con il comando
    vmplayer

Note :

Ho notato che questa versione di vmware player in accoppiata al kernel 2.6.24-18 non necessita di patch e quindi l’installazione prosegue senza problemi fino alla fine.

Se al contrario durante l’installazione ricevete un messaggio di errore potrebbe essere necessario utilizzare la patch, e quindi proseguire l’installazione come da punto 6 della guida iniziale.

Non avendolo testato consiglio, prima di tentare con la patch, di aggiornare ubuntu alle ultime versioni di kernel (ad oggi la 2.6.24-18 ) e di ripetere la re-installazione.

lunedì, 2 giugno 2008

GmailFS – Gmail come disco remoto in Ubuntu

Filed under: 8.04 Hardy Heron,linux,ubuntu — danny @ 11:33 am
Tags: ,

Testato su Ubuntu 8.04 Herdy Haron.

A differenza della guida ufficiale, vediamo come utilizzare gmailfs come utenti normali e non come root.

In questo modo non si riceverà più il fastidioso messaggio “ignored option rw” ogni volta che monteremo il disco remoto.

INSTALLAZIONE E CONFIGURAZIONE

  1. installiamo gmailFS :
    sudo apt-get install gmailfs
  2. creiamo nella home utente la cartella dove andremo a montare il drive. la chiamo per esempio gmail :
    mkdir ~/gmail
  3. copiamo il file di configurazione nella cartella utente ed apriamolo per modificarlo :
    cp /etc/gmailfs/gmailfs.conf ~/.gmailfs.conf
    gedit ~/.gmailfs.conf
  4. modifichiamo le voci username, password inserendo la user (senza @gmail.com) e la password dell’account gmail. Inoltre dare un nome al filesysstem modificando il campo fsname, questo è utile se si vogliono avere diversi filesystem virtuali nello stesso account. Esempio :
    [account]
    username = pippo
    password = pluto
    
    [filesystem]
    fsname = drive_principale
  5. salviamo e chiudiamo il file.

A questo punto gmailFS è configurato. Ogni volta che vogliamo utilizzare il drive basta dare i seguenti comandi :

MONTAGGIO

/sbin/mount.gmailfs /usr/bin/gmailfs.py ~/gmail/

SMONTAGGIO

fusermount -u ~/gmail/

oppure come al solito da root :

sudo umount ~/gmail/

Configurare Samba in Ubuntu 8.04 Hardy Heron

Filed under: 8.04 Hardy Heron,linux,ubuntu,Windows — danny @ 12:02 am
Tags: , , , ,

Ecco come configurare ubuntu 8.04 in modo da condividere facilmente cartelle e stampanti con altri computer della rete, siano essi linux o windows..

  1. installiamo samba :
    sudo apt-get install samba
  2. facciamo diventare l’utente corrente un utente samba assegnandogli una password :
    sudo smbpasswd -a NOMEUTENTE
  3. configuriamo il file di configurazione di samba. Creiamo un backup del file ed apriamo il file di configurazione :
    cd /etc/samba
    sudo cp smb.conf smb.conf.bak
    sudo gedit smb.conf
  4. se esempio vogliamo condividere una cartella che si trova nella home e che si chiama share incolliamo alla fine del file le seguenti righe, modificando NOMEUTENTE con il nome dell’utente del quale abbiamo precedentemente creato la password :
    [share]
    path = /home/NOMEUTENTE/share
    available = yes
    valid users = NOMEUTENTE
    read only = no
    browsable = yes
    public = yes
    writable = yes
  5. se non vogliamo modificare le opzioni di condivisione della cartella, salviamo ed usciamo.
  6. riavviamo il server samba con il seguente comando :
    sudo /etc/init.d/samba restart

Note :

  1. per configurare graficamente il file smb.conf è possibile installare la seguente gui :
    sudo apt-get install system-config-samba
  2. per ulteriori spiegazioni sul file smb.conf fare riferimento a
    man smb.conf

lunedì, 19 maggio 2008

Ubuntu 8.04 e Broadcom Wireless BCM4312 (rev 02)

Filed under: 8.04 Hardy Heron,linux,ubuntu — danny @ 7:43 pm
Tags: , , , , , ,

Testato su HP 6720s.

Verificare sempre che la vostra scheda di rete wifi sia effettivamente una Broadcom BCM4312.
Per farlo digitate da terminale

lspci | grep Broadcom\ Corporation

Se così è installiamo la scheda…

  1. Creiamo e posizioniamoci in una cartella di lavoro che alla fine potremo eliminare, per esempio :
    mkdir ~/bcm43xx; cd ~/bcm43xx
  2. Scarichiamo ora il driver windows e scompattiamolo :
    wget ftp://ftp.compaq.com/pub/softpaq/sp34001-34500/sp34152.exe
    sudo apt-get install cabextract
    cabextract sp34152.exe
  3. Digitiamo ora i seguenti comandi :
    echo 'blacklist bcm43xx' | sudo tee -a /etc/modprobe.d/blacklist
    sudo apt-get install ndiswrapper-utils-1.9
    sudo ndiswrapper -i bcmwl5.inf
    ndiswrapper -l
    sudo depmod -a
    sudo modprobe ndiswrapper
    sudo cp /etc/network/interfaces /etc/network/interfaces.orig
    echo -e 'auto lo\niface lo inet loopback\n' | sudo tee /etc/network/interfaces
    sudo ndiswrapper -m
    echo 'ndiswrapper' | sudo tee -a /etc/modules
    echo 'ENABLED=0' | sudo tee -a /etc/default/wpasupplicant
    sudo aptitude remove b43-fwcutter
  4. La riga seguente vale per Gnome, se usate KDE, Xfce o altro utilizzate il vostro editor di testo (es. kate,mousepad,…)
    sudo gedit /etc/init.d/wirelessfix.sh
  5. Incollare le seguenti righe nel file appena creato e aperto :
    #!/bin/bash
    modprobe -r b44
    modprobe -r b43
    modprobe -r b43legacy
    modprobe -r ssb
    modprobe -r ndiswrapper
    modprobe ndiswrapper
    modprobe b44
  6. Salviamo, chiudiamo il file ed eseguiamo gli ultimi  comandi :
    cd /etc/init.d/ && sudo chmod 755 wirelessfix.sh
    sudo update-rc.d wirelessfix.sh defaults
    
  7. Riavviare il computer

sabato, 10 maggio 2008

Immagini per VMware Player

Filed under: linux,ubuntu,virtualizzazione — danny @ 3:39 pm
Tags: , , , , , , ,

dTestBootDisk

Minimale virtual machine utile per testare dischi live scaricati (es. disribuzioni linux).

Funzionamento :

Se è presente un cd di boot nel lettore allora il sistema si avvierà con quello.

Altrimenti andrà a caricare un immagine “cd.iso” che dovrà essere presente nella stessa cartella del file dTestBootDisc.vmx (basta rinominare una iso esistente).

Caratteristiche :

hdd 4.7 gb (max)
ram 192 mb
cdrom1 : fisico
cdrom2 : immagine da rinominare in “cd.iso”
network : nat
altro : usb, sound

dUbuntuVM , dLinuxVM , dWindowsVM

Tre Virtual Machines pronte ed ottimizzate per installarci Ubuntu, Linux o Windows.

Funzionamento :

Per partire con l’installazione è sufficiente, prima di lanciare l’immagine, di inserire nel lettore cd/dvd principale il disco del sistema operativo; oppure se si dispone dell’immagine in formato .ISO basta rinominarla in “cd.iso” e metterla nella cartella della virtual machine (dove è contenuto il file .vmx).

Caratteristiche :

hdd 10 gb (max)
ram 320 mb
cdrom1 : fisico
cdrom2 : immagine da rinominare in “cd.iso”
network : bridged
altro : usb, sound

domenica, 14 ottobre 2007

Unix Programming : Pipe e Fifo

Filed under: c,linux,programming — danny @ 4:29 pm
Tags: , , ,
/* PIPE */
// permettono la comunicazione tra processi relazionati (es. padre-figlio)

int pipe(int fd[2])
// Invoca la creazione di una PIPE
// fd: puntatore ad un array di due interi (in fd[0] viene restituito il descrittore di lettura della PIPE,
// in fd[1] viene restituito il descrittore di scrittura della PIPE)
// fd[0] e fd[1] possono essere usati da subito (senza open() ) come normali descrittori di file tramite le chiamate read() e write()
// ­1 in caso di fallimento

/* NOTE:
1. Un processo lettore vede la �fine� della PIPE quando tutti i
processi scrittori hanno chiuso il descrittore fd[1].
2. La chiamata read() effettuata da un lettore restituisce 0 come
notifica dell�evento che tutti gli scrittori hanno terminato il loro lavoro
3. Un processo scrittore che tenti di scrivere sul descrittore fd[1]
quando tutte le copie del descrittore fd[0] sono state chiuse
(cioè non ci sono lettori sulla PIPE) riceve il segnale SIGPIPE
4. NB: Per evitare deadlock è necessario che tutti i processi
chiudano i descrittori di PIPE che non gli servono usando la close().
*/

/* FIFO */
// permettono la comunicazione tra processi relazionati e non

int mkfifo(char* name, int mode)
// Invoca la creazione di una FIFO
// name: puntatore ad una stringa che identifica il nome della FIFO da creare
// mode: intero che specifica la modalità di creazione e permessi di accesso alla FIFO (in genere O_CREATE | 0666)
// ­1 in caso di fallimento, altrimenti un descrittore per lâ��accesso alla FIFO

int unlink (const char * nomefifo)
// elimina dal sistema la fifo.
// NB: con la close chiudo la fifo ma non la elimino
// ­1 in caso di fallimento

int open (const char * nomefifo,int FLAGS)
// NB: è bloccante : un processo che tenta di aprirla in lettura (scrittura) viene bloccato
// fino a quando un altro processo non la apre in scrittura (lettura).
// FLAGS principali : O_RDWR, O_RDONLY, O_WRONLY, O_NONBLOCK (per rendere la open non bloccante)
// ­1 in caso di fallimento, altrimenti un descrittore per lâ��accesso al canale della FIFO

/* NOTE:
1.
2. La chiamata read() effettuata da un lettore restituisce 0 come
notifica dell�evento che tutti gli scrittori hanno terminato il loro lavoro
3. Un processo scrittore che tenti di scrivere sulla fifo
quando non ci sono lettori sulla fifo riceve il segnale SIGPIPE
4. per gestire una chiusura inaspettata del programma che ha creato la pipe
si usa catturare i seguenti segnali (la funz. disconnetti_pipe contiene una unlink)
signal(SIGTERM, disconnetti_pipe);
signal(SIGHUP, disconnetti_pipe);
signal(SIGINT, disconnetti_pipe);
per i processi che invece non haano creato la pipe è sufficiente gestire un SIGPIPE
signal(SIGPIPE, esci_dal programma);
*/

martedì, 10 luglio 2007

Personalizzare GRUB con uno sfondo

Filed under: linux — danny @ 7:48 pm
Tags: , , ,

In generale per personalizzare l’immagine di sfondo all’avvio di Grub occorre disporre di un immagine con le seguenti caratteristiche :

1. formato file xpm.gz

2. formato immagine 640×480 (14 colori)

Procediamo con Gimp…

1. apriamo il programma e creiamo una nuova immagine (CTRL-N oppure File->New) specificando una risoluzione di 640×480 (in alternativa possiamo aprire un’immagine che già possediamo e ridimensionarla a 640×480 pixel)

2. una volta creata l’immagine che ci piace occorre indicizzarla…per farlo andare in “Image->Mode->Indexed…” (oppure premere CTRL-I) e nella finestra che appare selezionare l’opzione “Generate optimal Palette” specificando in “# of colors” 14.

3. salvare quindi l’immagine (dove si vuole) come “splash.xpm”

4. adesso bisogna comprimere il file, per farlo basta aprire una finestra di terminale nella directory dove si è salvato l’immagine e digitare “gzip splash.xpm”

5. copiare ora il file “splash.xpm.gz” che abbiamo creato con il precedente comando nella directory “/boot/grub”

6. l’ ultimo passo consiste nel modificare il file di testo “menu.lst” nella directory “/boot/grub” aggiungendo (o decommentando) la seguente riga

“splashimage=(hd0,2)/boot/grub/splash.xpm.gz”

dove (hd0,2) va modificato con la propria partizione di boot nella forma di grub* (in genere è quella dove è installato linux…la trovi un po’ piu in basso nel file menu.lst)

*per esempio hda1 in grub è hd0,0 oppure hdb4 è hd1,3

domenica, 1 luglio 2007

Unix Programming : Segnali

Filed under: c,linux,programming — danny @ 2:47 pm
Tags: , ,
/* SEGNALI : EVENTI ASINCRONI */

/* sono segnalazioni asincrone generate in genere dal SO e da altri processi.
se non vengono gestite viene applicato il comportamento di default : chiusura del processo.
possibilità di gestione :
1. cattura del segnale   (e si esegue una certa routine)
2. ignoramento esplicito (non possibile per tutti i segnali es. SIGKILL)
2. ignoramento implicito (comp. di default)
Segnali più utilizzati:
SIGINT  : interrupt CTRL-C
SIGPIPE : già visto sopra
SIGALRM : inviato allo scadere di un timeout
SIGHUP  : si chiude il terminale
SIGTERM : chiusura non forzata processo
SIGUSRx : x=1,2,... definito dall'utente
*/

int kill (int pid, int segnale)
// non è la kill!!! ma serve per generare un segnale da inviare al processo pid
// tranne che se si è root, si possono inviare segnali solo a processi dello stesso utente
// è asincrona non bloccante.
// -1 in caso di fallimento

int raise(int segnale)
// invia un segnale al proesso corrente
// come kill (getpid(),sengale)

unsigned int alarm(unsigned int seconds);
// programma un timer interno al sistema operativo che invia al processo stesso un segnale SIGALRM dopo seconds secondi.
// restituisce il numero di secondi rimanenti alla generazione di un evento  impostato da una precedente chiamata ad alarm.
// Effettuare una chiamata ad alarm quando ne era stata già effettuata un�altra imposta il valore del timer
// pari a quello nell�ultima chiamata.

void (* signal(int sig, void (*func)(int))) (int);
// cattura il segnale sig e lancia la funzione func:
// func: puntatore alla funzione di gestione del segnale oppure SIG_DFL/SIG_IGN.
// ritorna SIG_ERR in caso di errore, altrimenti il valore della precedente funzione
// di gestione del segnale che viene sovrascritto con func.
//    SIG_DFL impone al processo il comportamento di default.
//    SIG_IGN impone al processo di ignorare esplicitamente il segnale.

int pause(void);
// blocca il processo in attesa di un qualsiasi segnale.
// ritorna sempre -1 e dopo la eventuale funzione di gestione (in una signal)
// non è possibile sapere direttamente da pause quale segnale ha provocato lo sblocco;
// si può rimediare facendo si che l�handler del segnale modifichi il valore di
// una variabile globale.

/* NOTE:
1. I processi figli ereditano le eventuali gestioni dei segnali (tranne se si ha una exec).
2. Possono interrompere sia funzioni di programma sia systemcall bloccanti, in questo caso
la chiamata non viene ripetuta e la variabile globale errno viene settata a EINTR.
Questo implica che la corretta invocazione di una systemcall bloccante è :
while ( systemCall() == -1 )
if ( errno != EINTR ) {
printf (�Errore!\\n�);
exit(1);
}
Infatti lo schema seguente non basta :
if ( systemCall() == -1 ) {
printf (�Errore!\\n�);
exit(1);
}
*/

/* LA GESTIONE DEI SEGNALI VISTA FINORA è INAFFIDABILE POICHé PUò GENERARE DEADLOCK!!!
questo poichè non si gestiscono segnali che possono arrivare in un breve lasso di tempo,
eventualmente minore del tempo di esecuzione dell'handler di gestione.
Per questo un processo può bloccare temporaneamente la consegna di un segnale (tranne SIGKILL).
In pratica si crea un accodamento gestito dalla SIGNAL MASK cioè una maschera che indica quali segnali
si stanno bloccando.
Si lavora sulla Signal Mask attraverso la struttura SIGSET_T ed alle funzioni : */

int sigemptyset (sigset_t *set);
// Svuota set.
int sigfillset (sigset_t *set);
// Mette tutti i segnali in set.
int sigaddset (sigset_t *set, int signo);
// Aggiunge il segnale signo a set.
int sigdelset (sigset_t *set, int signo);
// Toglie il segnale signo da set.
int sigismember (sigset_t *set, int signo);
// Controlla se signo è in set.

int sigprocmask(int how, const sigset_t *set, sigset_t *oset);
// modifica la signal mask.
// how: indica in che modo intervenire sulla signal mask e può valere:
//     SIG_BLOCK: i segnali indicati in set sono aggiunti alla signal mask;
//    SIG_UNBLOCK: i segnali indicati in set sono rimossi dalla signal mask;
//    SIG_SETMASK: La nuova signal mask diventa quella specificata da set;
// set: il signal set sulla base del quale verranno effettuate le modifiche.
// oset: se non è NULL, il backup della signal mask attuale/precedente
// -1 in caso di errore.

int sigpending(sigset_t *set);
// restituisce l�insieme dei segnali bloccati che sono attualmente pendenti.
// set: il signal set in cui verrà scritto l�insieme dei segnali pendenti.
// -1 in caso di errore.

int sigaction( int sig,
const struct sigaction * restrict act,
struct sigaction * restrict oact);
// Permette di esaminare e/o modificare l�azione associata ad un segnale.
// sig: il segnale interessato dalla modifica;
// act: indica come modificare la gestione del segnale;
// oact: backup della precedente struttura sigaction
// -1 in caso di errore.

struct sigaction {
void (*sa_handler)();
/* indirizzo del gestore o SIG_IGN o SIG_DFL*/
void (*sa_sigaction)(int, siginfo_t *, void*);
/* indirizzo del gestore che riceve informazioni addizionali
sul segnale ricevuto (utilizzato al posto di sa_handler se
sa_flags contiene SA_SIGINFO ) */
sigset_t sa_mask;
/* segnali addizionali da bloccare prima dell'esecuzione del gestore */
int sa_flags;
/* opzioni addizionali */
};

/* Notifiche (eventualmente multiple) dello stesso segnale durante l�esecuzione del
gestore sono bloccate fino al termine del gestore stesso (a meno che sa_flags valga NO_DEFER).
Con l�uso di sigaction l�azione specificata per il trattamento di un segnale rimane
attiva fino ad una successiva modifica.
*/

int sigsuspend(const sigset_t *sigmask);
// attende l�arrivo di un segnale.
// sigmask: prima di mettersi in attesa la funzione rende attiva questa signal mask;
// torna sempre -1 con errno che vale EINTR.
// una volta terminata, ripristina la signal mask precedente alla sua chiamata.
// Quando viene attivata, se esistono segnali pendenti che vengono sbloccati da
// sigmask, questi vengono immediatamente consegnati.
// Se non esistono segnali pendenti, oppure questi non vengono sbloccati, la funzione
// mette il processo in attesa dell�arrivo di un qualsiasi segnale non bloccato.

// ESEMPIO : passi da seguire per una gestione sicura dei segnali

// 1. definire l'handler di gestione
void myhandler(...)

// 2. dichiarazione strutture necessarie nel main
struct sigaction sig, oldsig;
sigset_t sigmask, oldmask, zeromask;
// le old sono solo di backup...potrebbe esser necessario utilizzarle (null altrimenti nelle successive chiamate)
// zeromask è una sigmask vuota che utilizziamo per disattivare il blocco

// 3. inizializzazione : blocco del segnale SIGUSR1
sigemptyset(&zeromask);

sigemptyset(&sigmask);
sigaddset(&sigmask,SIGUSR1);
sigprocmask(SIGBLOCK, &sigmask, &oldmask);
// ho aggiunto il sigset sigmask all'insieme dei segnali da bloccare

// 4. inizializzazione gestore di segnale
sig.sa_handler = myhandler;
sig.sa_flags = 0;
sigemptyset(&sig.sa_mask);
// sono segnali addizionali da bloccare prima del gestore...dipende dal programma

sigaction(SIGUSR1,&sig,&oldsig)
// quello che faceva la signal ma lo indirizzo al gestore e non direttamente all'handler

// 5. dipende dal programma :
// a questo punto in genere si creano i processi figli considerando che fin qui i segnali SIGUSR1 sono bloccati.
// se per esempio il figlio dovesse fare qualcosa ed inviare un segnale al padre allora una volta finito il suo lavoro :
kill(getppid(),SIGUSR1);
// sblocca il segnale qualora anche lui dovesse ricevere un segnale dal padre
sigsuspend(&zeromask);
// in pratica si mette in attesa di segnali rendendo attiva zeromask (che è vuota quindi non blocca niente)
// e ripristinando poi la sigmask precedente alla chiamata (quella che blocca SIGUSR1)
// il padre analogamente prima sblocca il segnale fa quello che deve fare ed eventualmente manda un segnale di risp al figlio

Unix Programming : Socket

Filed under: c,linux,programming — danny @ 2:43 pm
Tags: , ,
TCP_SERVER: socket,bind,listen,accept,(rcv/send),close
TCP_CLIENT: socket,connect,(send/rcv),close

UDP_SERVER: socket,bind,(rcvfrom/sendto),close
UDP_CLIENT: socket,(sendto/rcvfrom),close

/* strutture che utilizzeremo */

struct sockaddr_in {
u_char sin_len;
u_char sin_family;
u_short sin_port;
struct in_addr sin_addr;
char     sin_zero[8];
};
struct in_addr {
in_addr_t s_addr;
};
// sockaddr_in è definita in <netinet /in.h>

struct   hostent {
char    *h_name;       // official name of host
char    **h_aliases;   // alias list
int     h_addrtype;    // host address type
int     h_length;      // length of address
char    **h_addr_list; // list of addresses from name server
};
// hostent

/* SERVER */

int socket(int family, int type, int protocol)
// family = AF_INET (IPv4), AF_INET6 (IPv6), AF_LOCAL (local Unix)...
// type = SOCK_STREAM (TCP), SOCK_DGRAM (UDP), SOCK_RAW (for special IP packets, PING, etc. Must be root)
// protocol = 0 (used for some raw socket options)
// restituisce sockfd
// fare bzero() prima per inizializzare

int bind(int sockfd, const struct sockaddr *myaddr, socklen_t addrlen)
// la sockaddr è in lettura dal SO e può essere riempita con ip e porta altrimenti auto dal SO
// nota : un server può offrire servizi su + indirizzi ip se ha + interfacce di rete
// restituisce 0,-1

int listen(int sockfd, int backlog)
// mette in ascolto la server socket (passiva)
// backlog = num massimo di connessioni in attesa, in genere 5
// non serve nelle connessioni UDP
// restituisce 0,-1

int accept(int sockfd, struct sockaddr *clientaddr, socklen_t *addrlen)
// sockaddr scritto dal SO
// mette in attesa il server e restituisce il NUOVO sockfd che gestisce il client (un po' come welcomeSocket in java)

/* read &amp; write  */

int close(int sockfd)
// restituisce o,-1

/* CLIENT */

int socket(int family, int type, int protocol)
// family = AF_INET (IPv4), AF_INET6 (IPv6), AF_LOCAL (local Unix)...
// type = SOCK_STREAM (TCP), SOCK_DGRAM (UDP), SOCK_RAW (for special IP packets, PING, etc. Must be root)
// protocol = 0 (used for some raw socket options)
// restituisce sockfd del client per comunicare col server (ancora da associare)
// fare bzero() prima per inizializzare

int  connect(int socket fd, const struct sockaddr *serveraddr, socklen_t addrlen)
// sockaddr in lettura dal SO per indirizzare la connessione al server (va impostato prima)
// non ha senso in UDP
// restituisce 0,-1 non socket descriptor

// int bind ...!!! la usa il prof in una esercitazione di un echoClient UDP ???

/* read &amp; write  */

int close(int sockfd)
// restituisce o,-1

/* CLIENT &amp; SERVER  */

// inizializzazione
struct sockaddr_in myaddr;
bzero(myaddr, sizeof(myaddr) );
oppure memset(&amp;myaddr, 0, sizeof(myaddr) );

// funzioni di IO

int read (int sockfd, char* recvline, int size);
// legge size caratteri dal socket. Se la funzione legge meno dati di quanti richiesti da size, vuol dire che non ci sono dati da leggere.

int readline(int sockfd, char* recvline, int size);
// legge size caratteri dal socket. La funzione si blocca in lettura sul socket fino a quando non riceve una battuta di invio (un carattere di newline '\\n'.

int write(int sockfd, char* line, int size);
// scrive size caratteri nel socket. Se la funzione scrive meno byte di quanti richiesti da size, allora non c'è spazio disponibile nel buffer del socket.

// al posto* delle classiche read() &amp; write() posso utilizzare :

int recv(int sockfd, void *buffer, size_t mbytes, int flags)
int send(int sockfd, void *buffer, size_t mbytes, int flags)

// per UDP invece

int recvfrom(int sockfd, void *buffer, size_t mbytes, int flags, struct sockaddr *from, socklen_t *addrlen)
int sendto(int sockfd, void *buffer, size_t mbytes, int flags,  struct sockaddr to, socklen_t addrlen)

/* *hanno in + solo i flags :
MSG_DONTWAIT (this send non-blocking)
MSG_OOB (out of band data, 1 byte sent ahead)
MSG_PEEK (look, but don�t remove)
MSG_WAITALL (don�t give me less than max)
MSG_DONTROUTE (bypass routing table)
*/

struct hostent *gethostbyname(const char *hostname)
// restituisce l'indirizzo ip (in una struttura hostent) associato ad un nome di dominio (www oppure locale)

int gethostname(char *hostname, int bufferlen)
// ritorna il nome dell'host su cui viene lanciata

unsigned long inet_addr(char *addr)
//conversione formato indirizzo da dotted form a numeric (network byte order)

char* inet_ntoa(struct in_addr addr)
// viceversa con addr.s_addr = long int rappesentation

inet_aton("10.1.45.8", &amp;mio_servaddr.sin_addr);
// converte l'indirizzo ip passato come stringa, in una struttura in_addr.

// altre da studiare htons, htons, strtol

Pagina successiva »

Crea un sito o un blog gratuitamente presso WordPress.com.