In C vi sono diverse funzioni e strutture apposite per la creazione e l'uso dei socket. Le si possono trovare negli header "sys/socket.h", "sys/types.h", "sys/time.h", "unistd.h", "netinet/in.h", "netdb.h", che vanno inclusi a seconda delle funzioni e strutture che si intende usare.

Nelle seguenti tabelle vengono mostrate le funzioni principali (consultare il manuale per quelle prive di link) e gli header (che si trovano generalmente in "/usr/include") da includere per usarle. Successivamente verra' mostrato come creare ed utilizzare i socket con queste funzioni.
Tutti gli esempi riguardano i protocolli usati da internet (AF_INET).

La tipica modalita' di utilizzo dei socket e' la seguente:

1. Creazione del socket
2. Assegnazione indirizzo
3. Connessione/Attesa di una connessione
4. Scambio dati
5. Chiusura socket

CLIENT (client.c):

#include <sys/types.h>
#include <sys/socket.h>
//"in" per "sockaddr_in"
#include <netinet/in.h>
//"netdb" per "gethostbyname"
#include <netdb.h>

void ChiudiSocket(int sock)
{
  close(sock);
  return;
}

int CreaSocket(char* Destinazione, int Porta)
{
  struct sockaddr_in temp; 
  struct hostent *h;
  int sock;
  int errore;
  
  //Tipo di indirizzo
  temp.sin_family=AF_INET;
  temp.sin_port=htons(Porta);
  h=gethostbyname(Destinazione);
  if (h==0) 
  {
    printf("Gethostbyname fallito\n");
    exit(1);
  }
  bcopy(h->h_addr,&temp.sin_addr,h->h_length);
  //Creazione socket. 
  sock=socket(AF_INET,SOCK_STREAM,0);
  //Connessione del socket. Esaminare errore per compiere azioni
  //opportune in caso di errore.
  errore=connect(sock, (struct sockaddr*) &temp, sizeof(temp));
  return sock;
}

void SpedisciMessaggio(int sock, char* Messaggio)
{
  printf("Client: %s\n",Messaggio);
  //Si puo' notare il semplice utilizzo di write: 
  //write(socket, messaggio, lunghezza messaggio)
  if (write(sock,Messaggio,strlen(Messaggio))<0)
  {
    printf("Impossibile mandare il messaggio.\n");
    ChiudiSocket(sock);
    exit(1);
  }  
  printf("Messaggio spedito con successo.\n");
  return;
}

int main(int argc,char* argv[])
{
  int DescrittoreSocket;
  
  //Creo e connetto il socket
  DescrittoreSocket=CreaSocket("127.0.0.1",1745);
  
  //Spedisco il messaggio voluto
  if ((argc==2)&&(strcmp(argv[1],"exit")==0))
    SpedisciMessaggio(DescrittoreSocket,"exit");
  else
    SpedisciMessaggio(DescrittoreSocket,"Un messaggio");

  //Chiudo il socket.
  ChiudiSocket(DescrittoreSocket);

  return 0;
}

#include <sys/types.h>
#include <sys/socket.h>
//"in" per "sockaddr_in"
#include <netinet/in.h>
//"fcntl" per la funzione "fcntl"
#include <fcntl.h>

int CreaSocket(int Porta)
{
  int sock,errore;
  struct sockaddr_in temp;

  //Creazione socket
  sock=socket(AF_INET,SOCK_STREAM,0);
  //Tipo di indirizzo
  temp.sin_family=AF_INET;
  temp.sin_addr.s_addr=INADDR_ANY;
  temp.sin_port=htons(Porta);

  //Il socket deve essere non bloccante
  errore=fcntl(sock,F_SETFL,O_NONBLOCK);

  //Bind del socket
  errore=bind(sock,(struct sockaddr*) &temp,sizeof(temp));
  //Per esempio, facciamo accettare fino a 7 richieste di servizio
  //contemporanee (che finiranno nella coda delle connessioni).
  errore=listen(sock,7);
 
  return sock;
}

void ChiudiSocket(int sock)
{
  close(sock);
  return;
}

int main()
{
  //N.B. L'esempio non usa la funzione fork per far vedere l'utilizzo di
  //     socket non bloccanti

  char  buffer[512];
  int DescrittoreSocket,NuovoSocket;
  int exitCond=0;
  int Quanti;

  DescrittoreSocket=CreaSocket(1745);
  printf("Server: Attendo connessioni...\n");
  while (!exitCond)
  {
    //Test sul socket: accept non blocca, ma il ciclo while continua
    //l'esecuzione fino all'arrivo di una connessione.
    if ((NuovoSocket=accept(DescrittoreSocket,0,0))!=-1)
    {
      //Lettura dei dati dal socket (messaggio ricevuto)
      if ((Quanti=read(NuovoSocket,buffer,sizeof(buffer)))<0)
      {
         printf("Impossibile leggere il messaggio.\n");
         ChiudiSocket(NuovoSocket);
      }
      else
      {
         //Aggiusto la lunghezza...
         buffer[Quanti]=0;
         //Elaborazione dati ricevuti
         if (strcmp(buffer,"exit")==0)
              exitCond=1;
         else printf("Server: %s \n",buffer);
      }
      //Chiusura del socket temporaneo
      ChiudiSocket(NuovoSocket);
    }
  }
  //Chiusura del socket
  ChiudiSocket(DescrittoreSocket);
  printf("Server: Terminato.\n");

  return 0;
}

Il parametro "dominio" indica la famiglia di protocolli da usare. Tre delle possibili famiglie sono AF_UNIX (protocolli interni di Unix), AF_ISO (protocolli ISO) e AF_INET (protocolli usati da internet). In <sys/socket.h> sono definiti anche gli altri.

In "tipo", come dice lo stesso nome del parametro, viene indicato il tipo di comunicazione, cioe' in che modo debbano essere scambiati i dati. Puo' assumere diversi valori fra cui SOCK_STREAM (connessione permanente e bidirezionale basata su un flusso di byte: i dati vengono mantenuti in ordine e non sono persi o duplicati) e SOCK_DGRAM (scambio di datagram, ovvero pacchetti di byte di lunghezza massima fissata, non affidabile al 100% perche' la connessione non e' continua e quindi i pacchetti stessi possono essere duplicati e/o non arrivare in ordine).

Infine, il "protocollo", indica il particolare protocollo da usare con il socket. Normalmente assume valore nullo (0), cioe' il protocollo usato e' quello di default per la combinazione di dominio e tipo specificata con gli altri due parametri.
Per utilizzre, invece, un protocollo ben preciso, si puo' guardare il file "/etc/protocols" contenente i numeri associati ai tipi di protocolli possibili.

Il valore restituito, come gia' detto, e' il descrittore del socket. Questo valore va conservato perche' serve per ogni riferimento al socket creato.

Il socket creato e' "bloccante" per default. Un socket e' bloccante quando, a seguito di una chiamata alla funzione di attesa per una connessione, blocca il thread in cui e' stata creata, fino all'arrivo di una richiesta di connessione.
Per capire meglio il significato, si pensi ad un ciclo "while" in cui all'interno vi e' una attesa per una connessione. Con un socket bloccante, il ciclo non continuera' e si blocchera' fino all'arrivo di una richiesta di connessione.
Con un socket non bloccante, invece, non si ha una attesa indefinita. Se al momento della verifica, non e' presente alcuna richiesta di connessione, allora il thread continuera' con la propria esecuzione, senza bloccarsi.
Il modo di rendere un socket non bloccante e' il seguente (si assume che il descrittore del socket sia nella variabile intera con nome "sock"):

eventuale_errore=fcntl(sock,F_SETFL,0,NONBLOCK);

struct sockaddr
  {
    unsigned short int sa_family; // Fmiglia degli indirizzi.
    char sa_data[14]; // Dati dell'indirizzo.
  };

Nel caso di AF_INET, si avra' la struttura "sockaddr_in", definita in "netinet/in.h" (che quindi andra' incluso) ed equivalente, per mezzo di una conversione esplicita di formato, alla precedente:

  struct in_addr
  {
    unsigned int s_addr;
  };

  struct sockaddr_in
  {
    unsigned short int sin_family; // Famiglia degli indirizzi.
    unsigned short int sin_port; // Numero della porta (16 bit).
    struct in_addr sin_addr; // Indirizzi internet.
    // Campo per adattare la dimensione di sockaddr_in a quella della struttura "sockaddr".
    unsigned char sin_zero[sizeof (struct sockaddr) -
             sizeof (unsigned short int) -
             sizeof (unsigned short int) -
             sizeof (struct in_addr)];
  };

Un tipico modo di usare la struttura "sockaddr_in" e' il seguente:

//...
int eventuale_errore;
int sock;
struct sockaddr_in temp;
sock=socket(AF_INET,SOCK_STREAM,0); //Creazione del socket.
temp.sin_family=AF_INET;
temp.sin_addr.s_addr=INADDR_ANY;
temp.sin_port=htons(123); //Numero casuale.
eventuale_errore = bind(sock,(struct sockaddr*) &temp,sizeof(temp));
//...

#include <netdb.h>
...
struct sockaddr_in temp;
struct hostent *indirizzo_host;
int eventuale_errore;
int sock;
...
//Tipo di indirizzo
temp.sin_family=AF_INET;
//Porta d'ascolto sul server a cui ci si vuole connettere.
temp.sin_port=htons(321); //Numero casuale<
//"gethostbyname" restituisce una struttura di tipo "hostent" in cui mette
//l'indirizzo IP. Riceve in ingresso il nome dell'host che puo' essere
//un nome, in indirizzo IPv4 o un indirizzo IPv6.
//Nel caso di IPv4 o IPv6, il campo "indirizzo_host->h_addr" contiene il nome stesso.
indirizzo_host=gethostbyname("nome.inventato.it");
//Se hp contiene il puntatore nullo, allora la chiamata a gethostbyname e' fallita.
if (indirizzo_host==0)
{
  printf("Gethostbyname fallito\n");
  if (h_errno==HOST_NOT_FOUND) printf("host not found\n");
  if (h_errno==NO_ADDRESS) printf("name is valid but no has IP address\n");
  if (h_errno==NO_RECOVERY) printf("non recoverable name server error occurred\n");
  exit(1);
}
//Copio l'indirizzo nella struttura di tipo "sockaddr_in", nel campo relativo
//all'indirizzo.
bcopy(indirizzo_host->h_addr,&temp.sin_addr,indirizzo_host->h_length);
//Connessione del socket
eventuale_errore=connect(sock,(struct sockaddr*) &temp, sizeof(temp));

La funzione Listen si applica solo ai socket di tipo "SOCK_STREAM" o "SOCK_SEQPACKET" (vedi "socket").

Come sempre, in caso di errore, "accept" restituisce il valore "-1" e la variabile "errno" ne contiene il codice.

Se non e' presente alcun messaggio in arrivo, ed il socket e' "bloccante" (vedi "Il modo di rendere un socket non bloccante"), allora "recv" attende fino all'arrivo di un messaggio.

Esistono, comunque, altre due funzioni simili a "recv": sono recvfrom e recvmsg.

La struttura "sockaddr" e' descritta con la funzione "bind".

Vediamo un esempio di utilizzo di "getsockname".

//...
int eventuale_errore;
int sock;
struct sockaddr_in temp;
int dim=sizeof(temp);
...
eventuale_errore=getsockname(sock, (struct sockaddr*) &temp, &dim);
//In temp ci sono le informazioni sul protocollo, porta e indirizzi
//...