Simone Vellei (Henomis) Blog

E’ giunto il tempo di combattere, partiremo da windows7sins.org e dalla campagna di lotta contro il software proprietario e gli abusi delle corporation.

Ho tradotto parte del sito windows7sins.org e ho creato un volantino da stampare e diffondere. Potete scaricarlo qui.

Ecco un piccolo assaggio:

La nuova versione del sistema operativo Windows di Microsoft, Windows 7, ha lo stesso problema che Vista, XP e tutte le versioni precedenti hanno avuto: sono software proprietari. Gli utenti non hanno il permesso di condividere o modificare il software Windows, e nemmeno di esaminare come funziona all’interno. Il fatto che Windows 7 sia proprietario significa che Microsoft impone il controllo sui suoi utenti attraverso una combinazione di copyright, contratti e brevetti. La Microsoft usa questo potere per abusare degli utenti di computer. All’interno di windows7sins.org, la Free Software Foundation elenca sette esempi di abusi commessi dalla Microsoft…

 

Here my first Script-Fu for The Gimp. This script creates something like the upper image, adding a frame (background color-filled) and execute “drop-shadow” script. Two considerations:

• I’m happy, now I can post images on WordPress in easy&cool way
• Scheme just sucks.

Download: henomis-photoframe-script.scm.gz

To install copy it into ~/.gimp-x.y/scripts directory dependig on your gimp version.

Image from: here

Tremate, tremate le streghe son tornate

Ho la testa piena di idee, e questo è Bene, devo solo riordinarle un po’…sono stato assente per parecchio tempo nel mondo underground dell’informatica, voglio tornare nel mio habitat naturale. L’acqua in pentola bolle già, ho tanti ingredienti alcuni già usati per ricette già rodate, altri completamente nuovi. Voglio preparare una bella zuppa…

Stay tuned

Henomis

Per chi confonde ancora firefox con volpe di fuoco e ignora il panda rosso, ecco una simpatica galleria fotografica di Repubblica.it.

Settimana calda alla fiera Sicurezza a Milano. Ho avuto occasione di presentare Evolution la tastiera di nuova generazione del sistema SmartLiving della Inim Electronics, azienda presso la quale lavoro. Da qualche tempo mi sto occupando di questo progetto che finalmente ha fatto la sua apparizione in una delle maggiori fiere del settore.

Un istante della presentazione...

Evolution la tastiera evoluta per SmartLiving

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().