Simone Vellei (Henomis) Blog

Weekend trascorso nel tacco d’Italia. Un bellissimo tour panoramico dell’estremo Salento fra ulivi, terra rossa e le bianche pietre pugliesi. Tanto pesce e tantissime cose buone come il pasticciotto, il rustico, la puccia e le friselle. Troppi pochi giorni per poter visitare tutto il Salento, mi sono ripromesso di tornare (magari la prossima estate) per completare la visita, per vivere un po’ di mare roccioso e ballare pizzica e taranta.

Poco tempo fa mi sono imbattuto in un comportamento anomalo relativamente all’uso di una select() con timeout e un handler per il segnale SIGALRM. Il comportamento anomalo (documentato in parte su man 2 select) prevede che nel caso in cui la select() venisse interrotta da un segnale (SIGALRM nel mio caso) avrebbe come conseguenza la modifica del timeout passato come riferimento. Altra anomalia è data dal fatto che anche impostando la flag SA_RESTART, che forza la ri-esecuzione di una syscall interrotta da un segnale, la select() non si comporta come dovrebbe.

Fornisco un codice che ho prodotto per spiegare meglio la situazione…

#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>

typedef void (*sighandler_t)(int);

void alarm_hand()
{
 // do something
}

int main(int argc, char **argv)
{
 int res;
 int alarm_timeout, select_timeout;
 fd_set fset;
 struct timeval tv;
 struct sigaction act;

 if(argc != 3) {
  printf("usage: %s <alarm timeout> <select timeout>\n");
  exit(EXIT_FAILURE);
 }

 alarm_timeout = atoi(argv[1]);
 select_timeout = atoi(argv[2]);

 /* signal definition */
 act.sa_handler = alarm_hand;
 sigemptyset(&act.sa_mask);
 /* this flag should restart the interrupted syscall */
 act.sa_flags = SA_RESTART;
 sigaction(SIGALRM, &act, NULL);

 /* starting SIGALRM countdown */
 alarm(alarm_timeout);

 tv.tv_sec = select_timeout;
 tv.tv_usec = 0;

 FD_ZERO(&fset);
 FD_SET(STDIN_FILENO, &fset);

 /* this is a blocking syscall */
 res = select(STDIN_FILENO + 1, &fset, NULL, NULL, &tv);

 /* select error */
 if (res == -1) {
  printf("select error: %d seconds left!\n", tv.tv_sec);
  exit(EXIT_FAILURE);
 }
 /* select timeout */
 else if (res == 0) {
  printf("select timeout!\n");
  exit(EXIT_FAILURE);
 }
 /* there are something in stdin */
 else if (FD_ISSET(STDIN_FILENO, &fset)) {
  printf("stdin has you!\n");

  int n;
  char a;
  do {
   n = read(STDIN_FILENO, &a, 1);
   if(n!=0)
    printf("%c", a);
  } while((n!=0) && (a != '\n'));
 }

 exit(EXIT_SUCCESS);

}

Dopo averlo compilato con

$ gcc example.c -o example

il programmino che accetta un input da tastiera viene lanciato attraverso i due parametri alarm timeout e select timeout:

$ ./example <alarm timeout> <select timeout>

Si possono verificare i seguenti scenari:

• Si fornisce un input prima dello scadere di uno dei due timeout (Es. “ciao” seguito da RETURN): il programma termina correttamente e stampa l’input.
• Si inserisce alarm timeout maggiore di select timeout (Es. ./example 5 2): la select() termina correttamente essendo scaduto il suo timeout.
• Si inserisce select timeout maggiore di alarm timeout (Es. ./example 1 20): il processo riceve SIGALRM e la select termina in maniera anomala (non viene considerato il SA_RESTART).

Quindi se fate uso di select per la gestione di socket, file, ecc.. in concomitanza di un handler per SIGALRM prestate molta attenzione e riavviate “a mano” la select. Uno dei modi più eleganti è impostare una flag (di tipo sig_atomic_t!) dentro il gestore associato al segnale e gestirla all’interno del controllo d’errore della select().

A pochi istanti dall’uscita del nuovo browser di casa Google (Google Chrome) voglio pubblicamente motivare la mia scelta anticipata (Google Chrome non è ancora disponibile per GNU/Linux) di rimanere con Firefox come browser predefinito. Parte delle mie motivazioni riguardano alcuni dubbi sui Termini di servizio di Google Chrome. Mi riferisco ai punti:

• 11.1 L’utente è proprietario del copyright e di qualsiasi altro diritto già posseduto sui Contenuti inviati, pubblicati o visualizzati su o tramite i Servizi. Inviando, pubblicando o visualizzando i Contenuti, l’utente concede a Google una licenza perenne, irrevocabile, internazionale, non soggetta a diritti d’autore e non esclusiva per riprodurre, adattare, modificare, tradurre, pubblicare, eseguire in pubblico, visualizzare pubblicamente e distribuire qualsiasi Contenuto inviato, pubblicato o visualizzato su o tramite i Servizi. Detta licenza ha il solo scopo di autorizzare Google a visualizzare, distribuire e promuovere i Servizi e può essere revocata per alcuni Servizi, come definito nei Termini aggiuntivi dei Servizi in oggetto.
• 12.1 Il Software utilizzato dall’utente può scaricare e installare automaticamente aggiornamenti resi disponibili di volta in volta da Google. Tali aggiornamenti sono studiati per migliorare, potenziare e ulteriormente sviluppare i Servizi e possono assumere la forma di correzioni bug, funzioni potenziate, nuovi moduli software e versioni completamente nuove. L’utente accetta di ricevere tali aggiornamenti (e autorizza Google a fornirli) come parte dell’utilizzo dei Servizi.
• 17.1, 17.2 Alcuni Servizi sono finanziati dalle entrate derivanti dalla pubblicità e possono visualizzare annunci pubblicitari e promozioni. Tali annunci pubblicitari possono essere mirati al contenuto delle informazioni memorizzate nei Servizi, a ricerche effettuate tramite i Servizi o ad altre informazioni. Lo stile, le modalità e l’ambito degli annunci di Google sui Servizi sono soggetti a modifica senza specifico preavviso all’utente.

Detto questo lo vedo più come un’interfaccia al motore di rendering HTML Webkit usato, quest’ultimo, non solo nel browser Safari di casa Apple, ma anche nei dispositivi Nokia della serie S60. La velocità e la correttezza di rendering del browser Chrome, quindi, è data principalmente dall’integrazione di Webkit che, ricordo, è un progetto Open Source.

Dando a Cesare ciò che è di Cesare, chrome integra alcune feature che ritengo di qualche interesse:

• Separazione dei processi relativamente alle schede di navigazione.
• Integrazione di una virtual machine javascript.

Per gli utenti GNU/Linux che vogliono provare l’ebbrezza di utilizzare un browser basato su Webkit posso suggerire alcune prove. Mi riferisco per comodità ad istruzioni per la distribuzione Ubuntu:

$ sudo apt-get install libwebkitgtk1d

Si tratta delle libreria Webkit per Gtk+ che include un applicativo di esempio. Per lanciarlo sarà sufficiente il comando:

$ /usr/lib/WebKit/GtkLauncher

Altra prova, sempre usando le librerie Webkit, si può fare installando il browser Midori

$ sudo apt-get install midori

Si tratta di un browser minimale, ma con tanto di navigazione a schede, e casella di ricerca.

Non mi rimane altro che aspettare altri commenti su questo e altri blog…nel frattempo buona navigazione!