philpep's blog - tag C

Le parseur de wmfs

Tue, 20 Apr 2010 18:38:22 GMT

EDIT: ce billet se voulait une vulgarisation, mais il faut quand même savoir manipuler les notions d'automates, de grammaire etc. Si ça donne envie d'en savoir plus, tant mieux.

En même temps que j'ai laché dwm pour revenir au bon vieux (pas si vieux que ça) wmfs, j'ai totalement recodé le parseur du fichier de configuration.

Un fichier de configuration se doit d'être lisible, et sa projection en mémoire doit être facile à manipuler, malheureusement utiliser le même langage (comme le fait dwm avec son fichier de configuration directement en C) rend la configuration moins convi pour peu que l'on ne soit pas expert. Le parseur sert à ça, traduire un langage simple en langage compréhensible par la machine.

L'idée c'est d'expliquer un peu comment le parseur de wmfs fonctionne parce que ça touche une partie de l'informatique théorique que j'aime bien : l'étude des langages formels.

Yacc et lex sont souvent utilisés pour ce genre de choses. Mon code est juste une implémentation C d'un automate fini déterministe, il ne doit pas être loin du fonctionnement de yacc pour une grammaire et une syntaxe particulière (évidement yacc&lex sont beaucoup plus évolués que mon petit bout de code).

Donc le travail de lex c'est de lire le fichier caractère par caractère et de renvoyer des token, c'est à dire un identifiant syntaxique.

Le langage de configuration est comme ça :

[section]
    option = valeur
    truc = { "liste", 1, False }
    [sous-section]
        [sous-sous-section]
            machin = True
        [/sous-sous-section]
    [/sous-section]
[/section]

Je fais une première transformation purement syntaxique :

enum conf_type { SEC_START, SEC_END, WORD, EQUAL, LIST_START, LIST_END, NONE };
/* qui correspond à  [        [/    un_mot  =        {         }       autre */

Et je range ça dans deux listes chainées, une qui contient des conf_type et une autre qui contient les mots (des char *) :

Liste des TOKEN             Liste des mots (WORD)
SEC_START
WORD                        "section"
WORD                        "option"
EQUAL
WORD                        "valeur"
WORD                        "truc"
EQUAL
LIST_START
WORD                        "liste"
WORD                        "1"
WORD                        "False"
SEC_START
WORD                        "sous-section"
SEC_START
WORD                        "sous-sous-section"
WORD                        "machin"
EQUAL
WORD                        "True"
SEC_END
WORD                        "sous-sous-section"
SEC_END
WORD                        "sous-section"
SEC_END
    WORD                        "section"

Une fois ces deux piles construites, il suffit de dépiler en suivant la grammaire (c'est ce que fait yacc). C'est là qu'on parle d'états finis. Désolé ça aurait été plus compréhensible avec un schéma, mais je sais pas en faire donc j'ai écrit ça avec la syntaxe qu'on utilise pour décrire des grammaires.

start: /* rien */
       | SEC_START WORD sections SEC_END WORD start /* une suite de sections */
       ;

sections: /* rien */
           | SEC_START WORD sections SEC_END WORD /* des sous sections */
           | WORD EQUAL option sections /* des options */
           ;
option: WORD /* un mot tout simple (une valeur quoi) */
          | LIST_START list LIST_END /* une liste de valeurs */
          ;
 list: /* rien */
     | WORD list /* une liste de mots */
     ;

Le parseur va ainsi remplir une structure générique capable de contenir toutes les configurations qui respectent la grammaire et la syntaxe.

Pour wmfs en gros c'est ça :

struct conf_opt { /* options */
    char *name;
    char *val[10]; /* au plus 10 éléments dans une liste */
    SLIST_ENTRY(conf_opt) entry;
}
struct conf_sec { /* section */
    char *name;
    SLIST_HEAD(, conf_opt) optlist; /* liste chaînée des options de la section */
    TAILQ_HEAD(, conf_sec) sub; /* liste chaînée des sous sections */
    TAILQ_ENTRY(conf_sec) entry;
}

J'utilise abusivement des macros de <sys/queue.h>.

Ensuite il suffit de coder une API qui va récupérer des options/sections précises sur la structure, mais c'est pas le plus dur à faire.

Voilà un peu l'idée, l'intérêt de cette méthode c'est qu'elle est certaine (pas ou peu de bugs incompréhensibles), rapide : le fichier de configuration n'est traversé qu'une seule fois, pas besoin de strlen(), strchr(), strcmp(), strstr() qui prennent des plombes.

EDIT : j'ai failli oublier de donner le lien vers le code

realpath secure ?

Mon, 15 Mar 2010 00:00:00 GMT

Dans le cadre d'une application serveur (type transfert de fichier : http, ftp, ...), pour contrôler l'accès aux fichiers j'utilise realpath(3). Cette fonction permet d'avoir le path (chemin) réel d'un fichier, sans lien relatif dans un des dossiers. Ainsi on a juste à faire un strncmp(3) pour le comparer à la racine de l'application.

Par exemple une partie du code du serveur HTTP que je suis en train de coder (uri est quelque chose de la forme /../foo/bar/../machin.html et conf_root la racine du style /usr/local/www/

char path[PATH_MAX];
char root[PATH_MAX];

if (!realpath(uri+1, path) ||
        !realpath(conf_root, root) ||
        strncmp(path, root, strlen(root)) != 0)
    return send_error(404);

Prenez ce post pour une question, à part le chroot(2) et realpath, comment bien contrôler l'accès aux fichiers ?

J'y connais rien en filesystems, mais si on pouvait avoir un moyen rapide de savoir si un fichier est dans tel ou tel fichier ce serait grandement pratique. Sans me vanter j'ai souvent des idées géniales en informatique, mais bien souvent ça a été pensé et implémenté depuis plus de 10 ans ! Du coup si vous avez plus d'information, je suis prêt à converser sur ce sujet avec vous...

Jouons avec kvm

Sat, 13 Feb 2010 02:31:41 GMT

J'ai codé un petit programme tout simple qui fait clignoter les leds de mon routeur dès qu'un service est par terre. Ma méthode (qui ne doit pas être la meilleure mais je m'en fout un peu) consiste à regarder régulièrement la liste des processus et détecter l'arrêt d'un service quand le processus associé n'existe plus. J'ai commencé avec un script shell, puis étant assez mauvais pour tout ce qui ressemble de près ou de loin à du script j'ai décidé de le faire en C (langage d'excellence n'est ce pas...?).

Je me suis volontairement compliqué la tache en utilisant des fonctions très proches du système, ainsi s'il est possible d'obtenir une liste de processus via ps(1) avec un popen(3) super crade ou encore sysctl(3) j'ai voulu utiliser kvm(3) kernel memory interface qui est en programmation système la méthode la plus appropriée (d'ailleurs 'ps' est codé avec ça), c'est juste une interface qui va nous permettre d'accéder au données du kernel (une copie bien entendu), ici la liste des processus en cours.

Le hic c'est que si les fonctions de kvm sont très standard l'implémentation est très différente suivant les systèmes, comme à peu près toute implémentation, l'important c'est que l'interface soit standard. Ainsi à la lecture de la structure qui décrit les processus kinfo_proc de sys/user.h on se dit chouette pleins d'info à disposition, sauf que sur OpenBSD c'est pas du tout la même forme (ni le même fichier d'ailleurs). D'où l'importance d'une interface riche et c'est ce que nous promet kvm.

Assez causé passons au code (je n'explique pas ou peu le code en dehors des fonctions kvm)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <err.h>
#include <libgen.h>
#include <fcntl.h>
#include <limits.h>
#include <paths.h>
#include <kvm.h>
#include <sys/param.h>
#include <sys/sysctl.h>
#include <sys/wait.h>
#include <sys/user.h>

void
start_leds(void)
{
    /* Ici on execute /usr/sbin/gioctl -q gpio0 led3 (on|off)
     * suivant la parité du conteur statique 'i'
     * 60 fois avec une pause d'une seconde. */
    static int i = 1;
    switch(fork())
    {
        case -1:
            err(1, "fork");
            break;
        case 0:
            execl("/usr/sbin/gpioctl", "gpioctl", "-q", "gpio0",
                    "led3", (i%2) ? "on" : "off", (char*)NULL);
            err(1, "execl");
            break;
        default:
            wait(NULL);
            break;
    }
    sleep(1);
    if (i++ <= 60)
        return start_leds();
    return;
}

int
main(int argc, char *argv[])
{
    kvm_t *kd;
    char berr[_POSIX2_LINE_MAX];
    struct kinfo_proc *p, *procs;
    int n, j, k, found = 0;
    char **pargv;

    if (argc < 2)
        errx(1, "Usage check_proc procs ...");

    /* On accède aux données du kernel qui tourne actuellement (NULL) */
    if (!(kd = kvm_open(NULL, NULL, NULL, O_RDONLY, berr)))
        errx(1, "%s", berr);

    /* On demande la liste des processus, kinfo_proc est décrite
     * dans sys/sysctl.h sur OpenBSD et sys/user.h sur FreeBSD.
     * Il nous la donne dans un tableau continu de pointeurs de
     * taille qu'on récupère dans 'n'. */
    if (!(procs = kvm_getprocs(kd, KERN_PROC_ALL, 0, &n)))
        err(1, "kvm_getprocs: %s", kvm_geterr(kd));

    for (k = 1; k < argc; k++)
    {
        for (j = 0, p = procs; j < n; j++, p++)
        {
            /* On accède à la liste des arguments du programme qui a
             * généré le processus courant. */
            pargv = kvm_getargv(kd, p, 0);
            if (pargv && pargv[0] &&
                    strstr(pargv[0], argv[k]))
                {
                    found++;
                    break;
                }
        }
    }

    if (-1 == kvm_close(kd))
        err(1, "kvm_close");

    if (found != argc-1)
        start_leds();

    return 0;
}

Et l'exécution, on veut tester si un processus du nom de 'dhcpd' tourne sur le système, si ce n'est pas le cas on lance le clignotement de la led pendant une minute :

# gcc -o check_proc check_proc.c -lkvm
# ./check_proc dhcpd

Le mien s'exécute dans un cron toute les minutes :

* * * * * /root/bin/check_proc named dhcpd adsuck ntpd

Un système de ramasse miette en C

Sat, 03 Oct 2009 00:00:00 GMT

Je viens d'implémenter dans mon shell un système de ramasse miette. Le choix de faire un tel système est particulièrement adapté pour un shell ou pour tout programme qui est fortement cyclique et avec un cycle assez court où chaque allocation peut être libérée rapidement.

En gros l'astuce consiste à créer des fonctions wrapper pour free(3) et malloc(3). Une fois que tous nos appels d'allocation et de libération de mémoire passent par eux il est facile de créer une structure de type pile qui empile l'adresse de chaque allocation pour ensuite tout libérer d'un coup à la fin du cycle.

Pour cela j'ai utilisé les SLIST de sys/queue.h pour la pile que voilà :

typedef struct stack_s {
    void * adr;
    SLIST_ENTRY(stack_s) next;
} stack_s;

Ensuite le wrapper pour malloc (notez qu'on déclare la tête de pile comme variable globale (dans le fichier avec les fonctions wrapper) pour pouvoir y accéder facilement.

/* déclaration de la pile mstack (qu'on initialise à NULL) */
static SLIST_HEAD(, stack_s) mstack = SLIST_HEAD_INITIALIZER(&mstack);

/* Le wrapper pour malloc */
void *
xmalloc(size_t size)
{
    void *ret;
    stack_s *el; /* l'élément a rajouter dans la pile */

    ret = malloc(size);

    if (!ret)
    {
        perror("Malloc ");
        exit (EXIT_FAILURE);
    }

    el = malloc(sizeof(*el));
    el->adr = ret;
    SLIST_INSERT_HEAD(&mstack, el, next);

    return ret;
}

/* Cette fonction vide toute la pile et libère la mémoire */
void
stack_delete(void)
{
    stack_s *el;

    while (!SLIST_EMPTY(&mstack))
    {
        el = SLIST_FIRST(&mstack);
        SLIST_REMOVE_HEAD(&mstack, next);
        free(el->adr);
        free(el);
    }

    return;
}

Voilà, maintenant faites tous vos allocations temporaires avec _malloc et videz la pile de temps en temps (ie à la fin du cycle général de votre programme).

Par exemple dans la boucle principale ça donne quelque chose comme ça :

for (;;)
{
    machin = xmalloc(sizeof(*machin) * 10);
    /*
        ...
        ...
    */

    stack_delete();
}

J'espère que c'est compréhensible, si vous avez une question n'hésitez surtout pas à me demander plus d'information.

Petite présentation de sys/queue.h

Sat, 26 Sep 2009 22:27:29 GMT

Dans vos programmes C, il arrive très fréquemment d'utiliser des listes chaînée (de toutes sortes), afin de ne pas avoir à recréer le monde à chaque fois vous pouvez utiliser les macros super pratiques de queue(3). Voici une petite introduction à l'utilisation de sys/queue.h avant d'aller se plonger dans le man pour aller plus loin.

Avec sys/queue.h , vous pouvez manipuler facilement quatres sortes de listes :

Listes simplement chainées (SLIST) de type pile
Listes doublement chainées (LIST) de type pile
Listes simplement chainées (STAILQ) de type file
Listes doublement chainées (TAILQ) de type file

Voici un exemple de SLIST :

Le header :

#ifndef HEADER_H
#define HEADER_H

#include <sys/queue.h>

typedef struct MaStruct {
    /* ici on met nos elements par exemple : */
    char *str;

    /*
     * On déclare notre liste avec SLIST_ENTRY qui est equivalente à
     * struct { struct MaStruct *sle_next; } next;
     */

    SLIST_ENTRY(MaStruct) next;
} MaStruct;

#endif /* HEADER_H */

Ensuite voyons comment manipuler cette liste :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "header.h"

int
main(void)
{
    /* SLIST_HEAD crée une variable pour acceder à notre liste */
    SLIST_HEAD(, MaStruct) head;

    /* on crée un element MaStruct */
    MaStruct *p;

    /* On l'initialise à NULL */
    SLIST_INIT(&head);

    p = malloc(sizeof(*p));
    p->str = malloc(sizeof(char) * 10);
    strcpy(p->str, "blah");

    /* On insere p dans la SLIST */
    SLIST_INSERT_HEAD(&head, p, next);

    /* On empile un deuxième element */
    p = malloc(sizeof(*p));
    p->str = malloc(sizeof(char) * 10);
    strcpy(p->str, "blu");

    SLIST_INSERT_HEAD(&head, p, next);

    /*
     * Il est très facile de parcourir la liste
     * que ce soit pour du traitement ou de
     * la libération de mémoire
     */
    SLIST_FOREACH(p, &head, next) {
        /* ici p est l'element courant */
        printf("element : %s\n", p->str);
    }

    /* exemple de libération */
    while (!SLIST_EMPTY(&head))
    {
        p = SLIST_FIRST(&head);
        SLIST_REMOVE_HEAD(&head);
        free(p->str);
        free(p);
    }

    return 0;
}

Parmis les macros interessantes pour les SLIST il y a :

SLIST_FIRST(&head);                /* renvoie la tête de liste */
SLIST_REMOVE_HEAD(&head, next);    /* supprime la tete de liste */
SLIST_EMPTY(&head); /* renvoie vrai si la liste est vide */

Ben entendu, il y a beaucoup plus de possibilités avec LIST et TAILQ... Mais globalement vous devriez avoir compris le principe.

La lecture de sys/queue.h devrait vous éclairer pour comprendre comment marchent toutes ces macros, c'est assez facile à comprendre si vous avez (comme moi) un niveau moyen en C.

Voyez aussi ce papier d'iMil.

Parser une saisie en C avec la fonction strtok

Thu, 10 Sep 2009 21:53:37 GMT

Si vous récupérez une saisie de l'utilisateur et que vous souhaitez l'analyser selon une syntaxe particulière pour en retirer des arguments c'est que vous voulez parser la saisie.

Une solution simple et portable en C est la fonction strtok de string.h . Par exemple si à partir de la chaine char str = "fonction argument1 argument2" vous voulez obtenir un char **argv = {"fonction", "argument1", argument2"} c'est une bonne idée d'utiliser la fonction strtok.

On pourrait croire qu'il y a plus simple, juste en utilisant quelques pointeurs, mais imaginez un peu que l'utilisateur s'amuse a mettre des espaces n'importe comment par exemple " fonction argument1 argument2 " ...

Donc voici un code qui permet d'allouer juste comme il faut votre char **argv :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_ARG 10
#define SIZE 256

int main(void)
{
   char **argv = NULL;
   char *saisie = malloc(sizeof(char) * SIZE);
   char *p = NULL;
   size_t i = 0;
   char c;
   /* On recupère la saisie */
   printf(">");
   fgets(saisie, SIZE, stdin);
   /* On supprime le de la fin */
   if(NULL != (p = strrchr(saisie, ' ')))
      *p = '\0';
   else
      while(' ' != (c = fgetc(stdin)) && c != EOF);

   /* On alloue argv */

   argv = malloc(sizeof(char *) * MAX_ARG);

   /* 
    * On lance le premier strtok
    * char *strtok(char *ptr, char *str);
    * ptr doit être la saisie qu'on veut parser
    * et str est une chaine qui contient les caractères
    * sur lesquels on va couper la saisie. Vous pouvez
    * bien sûr en mettre plusieurs
    */
   p = strtok(saisie, " ");
   while(p != NULL)
   {
      /* 
       * Ici p est un pointeur sur une chaine
       * qui contient exactement l'argument i
       */
      if(i < MAX_ARG)
      {
         argv[i] = malloc(sizeof(char) * (1+strlen(p)));
         strcpy(argv[i], p);
         i++;
      }
      else
         break;
      /* 
       * On lance un nouvel appel a strtok
       * par contre on lui donne en argument NULL
       * pour qu'il sache que c'est celle du dernier
       * appel, on peut aussi changer les caractères
       * pour parser...
       */
      p = strtok(NULL, " ");
   }

   argv[i] = NULL;

   /* On affiche les resultats */
   for(i = 0; argv[i] != NULL; i++)
   {
      printf("arg[%d] = '%s' ", i, argv[i]);
      free(argv[i]);
   }
   free(argv);
   free(saisie);
   return 0;
}

Attention : la chaine saisie a été modifiée par strtok, elle ne doit pas avoir l'attribut const pour ça. D'ailleurs si vous envoyez une chaine constante à strtok ça fait un segfault...

Bon, le seul problème avec cette technique c'est que strtok ne nous dit pas sur quel caractère il a coupé la chaine. Mais ça reste un moyen rapide d'arriver à faire quelque chose de propre...

Bons codes :-)

EDIT : Il manquait quelques free...

Lire /etc/passwd pour avoir des informations en C

Thu, 10 Sep 2009 00:00:00 GMT

Dans vos programmes C, il peut arriver d'avoir besoin d'informations concernant l'utilisateur du programme (Son $HOME pour y enregistrer des fichier par exemple).

Une manière simple (et portable) de procéder est d'utiliser les variables d'environnement. Par exemple : getenv.c

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
   printf("login: %s ", getenv("USER"));
   printf("home: %s ", getenv("HOME"));
   printf("shell: %s ", getenv("SHELL"));
   return 0;
}

Ce qui doit donner quelque chose dans ce gout là :

$ gcc getenv.c
$ ./a.out

login: phil
home: /home/phil
shell: /usr/local/bin/zsh

Mais le problème c'est que ce qui est mis dans l'environnement par défaut diffère suivant les OS, et même suivant les distributions GNU/Linux ou BSD, ainsi il n'est pas rare de trouver LOGIN à la place de USER et autre subtilités. De plus cette méthode n'est efficace que si l'environnement est bien initialisé lors du lancement du processus. Lancez votre programme avec env -i pour lui envoyer un environnement vide :

$ env -i ./a.out

login: (null)
home: (null)
shell: (null)

Pas bon donc. Donc pour faire quelque chose de plus propre il est nécessaire sous UNIX de lire le fichier /etc/passwd, dieu merci les structures et les fonctions qui vont bien sont dans unistd.h et pwd.h

Voici la structure passwd qui définie complètement un utilisateur UNIX : man pwd.h

struct passwd {
    char   *pw_name;       /* user name */
    char   *pw_passwd;     /* user password */
    uid_t   pw_uid;        /* user ID */
    gid_t   pw_gid;        /* group ID */
    char   *pw_gecos;      /* real name */
    char   *pw_dir;        /* home directory */
    char   *pw_shell;      /* shell program */
};

Donc il nous faut une fonction pour récupérer la structure qui correspond à notre utilisateur. En gros il y a deux fonctions qui font ça (de pwd.h) :

struct passwd *getpwnam(const char *name);
struct passwd *getpwuid(uid_t uid);

Donc en gros soit vous connaissez le login de l'utilisateur et vous utilisez la première. Soit vous connaissez l'uid de l'utilisateur et c'est la seconde. Pour avoir l'uid du processus courant il y a uid_t getuid(void); dans unistd.h

Donc voici un exemple avec getpwuid qui marchera à tous les coups (sauf en cas de graves problèmes dans le système) :

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <pwd.h>

int main(void)
{
   uid_t uid;
   struct passwd *user;

   uid = getuid();
   user = getpwuid(uid);

   printf("login: %s ", user->pw_name);
   printf("home: %s ", user->pw_dir);
   printf("shell: %s ", user->pw_shell);
   return 0;
}

Compilation et lancement dans un environnement vide :

$ gcc users.c
$ env -i ./a.out

login: phil
home: /home/phil
shell: /usr/local/bin/zsh

Et voilà. Attention tout de même, si ce code arrive à se trouver dans une boucle il va lire à chaque fois le fichier /etc/passwd ce qui n'est pas une bonne idée. Donc il peut être utile de stocker ces informations (ces pointeurs) dans une structure globale ou bien de les mettre dans l'environement (putenv, setenv)

Enjoy et bon codes.

Que font vos processus ? La commande strace

Sat, 05 Sep 2009 20:27:35 GMT

J'ai découvert une commande ulta utile, que ce soit pour la sécurité ou pour débuger : la commande strace.

Comme vous le savez, lorsque vous codez en C ou en tout autre langage le code est traduit en langage machine mais il peut aussi faire appel aux fameux "appels systèmes" gérés par l'OS (comme par exemple cloner des processus, accéder à un fichier, afficher quelque chose à l'écran...). Mais comment avoir la trace de toutes ces informations ? La commande strace fait tout cela.

Sur *BSD, vous pouvez utiliser de manière analogue truss(1).

Dans la pratique, strace permet de voir ce que fait un processus, on y accède en lui donnant le PID du processus (qu'on peut avoir avec la commande ps). Par exemple si je veux savoir ce que fait mon shell :

% ps
3982 pts/3    00:00:00 zsh
# Une fois qu'on a le pid on lance strace (dans un autre shell)
% strace -p3982

Regardons un peu ce qu'il se passe pour un simple ls :

# Lecture d'un l au clavier
read(10, "l"..., 1)                     = 1
# écriture du l a l'écran (celui qu'il vient de lire
write(10, "l"..., 1)                    = 1
# Lecture du s
read(10, "s"..., 1)                     = 1
# ecriture du s
write(10, "\10ls"..., 3)                = 3
# lecture de la touche enter (en C)
read(10, "
"..., 1)                    = 1
write(10, "
"..., 2)                 = 2
alarm(0)                                = 0
ioctl(10, SNDCTL_TMR_STOP or TCSETSW, {B38400 opost isig icanon echo ...}) = 0
time(NULL)                              = 1229629587
pipe([3, 4])                            = 0
gettimeofday({1229629587, 864550}, {0, 0}) = 0
# clone ----> un nouveau processus est crée en fait fork() execute l'appel système clone, le nouveau pid est 4024
clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0xb7ddd998) = 4024
close(4)                                = 0
read(3, ""..., 1)                       = 0
close(3)                                = 0
rt_sigprocmask(SIG_BLOCK, [CHLD], [CHLD], 8) = 0
rt_sigsuspend([])                       = ? ERESTARTNOHAND (To be restarted)
--- SIGCHLD (Child exited) @ 0 (0) ---
rt_sigprocmask(SIG_BLOCK, ~[RTMIN RT_1], [CHLD], 8) = 0
rt_sigprocmask(SIG_SETMASK, [CHLD], ~[KILL STOP RTMIN RT_1], 8) = 0
# La fin du processus fils (4024)
wait4(-1, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], WNOHANG|WSTOPPED, {ru_utime={0, 0}, ru_stime={0, 0}, ...}) = 4024
gettimeofday({1229629587, 867012}, {0, 0}) = 0
ioctl(10, SNDCTL_TMR_TIMEBASE or TCGETS, {B38400 opost isig icanon echo ...}) = 0
ioctl(10, TIOCGPGRP, [4024])            = 0
ioctl(10, TIOCSPGRP, [3982])            = 0
ioctl(10, TIOCGWINSZ, {ws_row=38, ws_col=127, ws_xpixel=1270, ws_ypixel=758}) = 0
wait4(-1, 0xbfe3f48c, WNOHANG|WSTOPPED, 0xbfe3f434) = -1 ECHILD (No child processes)
# Il se demande quelle heure est il :-)
time(NULL)                              = 1229629587
ioctl(10, TIOCSPGRP, [3982])            = 0
fstat64(0, {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 3), ...}) = 0
fcntl64(0, F_GETFL)                     = 0x2 (flags O_RDWR)
# Il se demande sous quel UID il tourne
getuid32()                              = 1000
# Il reécris le prompt
write(1, "\33]0;phil@philpep.ath.cx ~\7"..., 26) = 26
rt_sigprocmask(SIG_BLOCK, [CHLD], [CHLD], 8) = 0
# Il se redemande quelle heure il est
time(NULL)                              = 1229629587
rt_sigaction(SIGINT, {0x80a8fd0, [], SA_INTERRUPT}, NULL, 8) = 0
write(10, "\33[1m\33[3m%\33[23m\33[1m\33[0m           "..., 149) = 149
time(NULL)                              = 1229629587
# Il ouvre le fichier /etc/localtime
stat64("/etc/localtime", {st_mode=S_IFREG|0644, st_size=2945, ...}) = 0
ioctl(10, FIONREAD, [0])                = 0
ioctl(10, TIOCSPGRP, [3982])            = 0
ioctl(10, SNDCTL_TMR_STOP or TCSETSW, {B38400 opost isig -icanon -echo ...}) = 0
write(10, "
\33[0m\33[23m\33[24m\33[J\33[01;30m[\33[01;3"..., 105) = 105
write(10, "\33[K\33[81C  \33[01;30m18/12/08 20:46:"..., 46) = 46
# Il attend une nouvelle saisie
read(10, 
Process 3982 detached

(Là j'ai viré pas mal de lignes répétitives sur les signaux reçus par le processus)

Bon, vous voyez qu'il y a un tas d'appel système, et encore il a fait un fork(), c'est à dire qu'un nouveau processus a été crée... Pour suivre aussi les nouveaux processus il suffit d'un :

% strace -f -pPID

Attention, le log peut être très long, donc je vous conseille d'envoyer tout ça dans un fichier, pour donner un ordre d'idée, un simple chargement d'une page dans firefox donne plus de 59000 appels systèmes.

% strace -f -pPID > strace.log 2>&1

Avec ces informations vous pouvez faire du debugage (je me suis rendu compte que mon shell ne fermais pas ses fichiers quand il ne trouvais pas de complétion possible. C'est aussi grâce a ce genres de vérification qu'on s'est rendu compte que le charmant logiciel propriétaire skype ouvrait le fichier bookmaks.html (les favoris de firefox) et les envoyais à la maison mère... C'est une façon rapide de prouver qu'un logiciel propriétaire est malveillant.

Une variable qui en contient d'autres en C

Sat, 05 Sep 2009 19:43:52 GMT

Vous en avez marre d'avoir des fonctions C avec un maximum de paramètres qui rendent le code illisible. Par exemple :

char *prompt (int afficher_nom, int afficher_host, int afficher_pwd, int couleurs);
/* ou les afficher_* valent 0 ou 1 suivant si on veut que l'action s'éxecute.) */

Clairement en plus d'être imbuvable votre prototype n'est pas bon en terme de mémoire, un int est beaucoup trop grand pour contenir une variable booléenne. Il y a une technique pour n'utiliser qu'une seule variable de type unsigned int qu'on appellera flags (ce nom vous dit peut être déjà quelque chose). On va pouvoir transmettre plusieurs informations dans cette unique variable.

NOTA : Je vais juste vous expliquer comment faire dans la pratique, mais je ne vais pas expliquer pourquoi ça marche. La technique s'appuie sur les opérateurs binaires et sur l'algèbre de Boole.

Donc on va mettre ceci dans notre header, le prototype de notre fonction est beaucoup plus lisible :

#ifndef H_HEADER
#define H_HEADER

#define NOM      (0)
#define HOST     (1)
#define PWD      (2)
#define COULEURS (4)
/* Notez que tous les flags doivent être une puissance de 2
 * 0  1 2  4  8  16  32  64  128  512  1024 etc */
/* Prototype de la fonction */
char *prompt(unsigned int flags);
#endif /* H _HEADER */

/* Pour avoir que flags contienne juste NOM et COULEURS, on fait comme ceci : */
flags = NOM | COULEURS;
/* Si on veut rajouter un flags (HOST par exemple) : */
flags |= HOST;
/* Si par la suite on veut supprimer un flags (NOM par exemple) : */
flags &= ~NOM;
/* Pour tester si un flags est dans notre variable (COULEURS par exemple) : */
if (flags & COULEURS)
{
    /* Ce test sera vrai seulement si COULEURS est dans flags */
}

Un dernier petit code pour l'exemple :

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(void)
{
    unsigned int toto = COULEURS | NOM | PWD;
    char *pwd = get_current_dir_name();
    char *prompt;

    if(pwd)
        free(pwd);
    /* On enlève PWD */
    else
        toto &= ~PWD;

    /* On rajoute HOST */
    toto |= HOST;

    /* On appelle la fonction */
    prompt = prompt(toto);

    /* .... */
    return 0;
}
/* suite du code */

Voilà, abusez de cette technique infiniment pratique.

Voir à ce sujet ce tutoriel.