Un programme de ligne de commande peut-il empêcher sa sortie d'être redirigée?

Je suis devenu tellement habitué à faire ceci: someprogram >output.file

Je le fais chaque fois que je veux enregistrer le résultat généré par un programme dans un fichier. Je connais également les deux variantes de cette redirection IO :

• someprogram 2>output.of.stderr.file (pour stderr)
• someprogram &>output.stderr.and.stdout.file (pour les deux stdout + stderr combinés)

Aujourd'hui, j'ai rencontré une situation que je n'aurais pas cru possible. J'utilise la commande suivante xinput test 10et comme prévu, j'ai la sortie suivante:

utilisateur @ nomhôte: ~ $ xinput test 10
touche enfoncée 30 
libération de clé 30 
touche 40 
libération de clé 40 
touche 32 
libération de clé 32 
touche 65 
libération de clé 65 
touche 61 
libération de clé 61 
touche 31 
^ C
utilisateur @ nom d'hôte: ~ $ 

Je pensais que cette sortie pourrait, comme d’habitude, être sauvegardée dans un fichier similaire à xinput test 10 > output.file. Mais lorsque cela est contraire à mes attentes, le fichier output.file reste vide. Ceci est également vrai pour xinput test 10 &> output.filem'assurer que je ne manque rien sur stdout ou stderr.

Je suis vraiment confus et demande donc ici si le xinputprogramme aurait un moyen d'éviter que sa sortie soit redirigée?

mise à jour

J'ai regardé la source. Il semble que la sortie soit générée par ce code (voir l'extrait de code ci-dessous). Il me semble que la sortie serait générée par un printf ordinaire

// dans le fichier test.c

static void print_events (Display * dpy)
{
    Événement XEvent;

    tandis que (1) {
    XNextEvent (dpy, & Event);

    // [... d'autres types d'événements sont omniprés ici ...]

        if ((Event.type == key_press_type) ||
           (Event.type == key_release_type)) {
        boucle int;
        XDeviceKeyEvent * key = (XDeviceKeyEvent *) & Event;

        printf ("clé% s% d", (Event.type == key_release_type)? "release": "appuyez sur", clé-> code de touche);

        for (loop = 0; loopaxes_count; loop ++) {
        printf ("a [% d] =% d", clé-> first_axis + boucle, clé-> axis_data [boucle]);
        }
        printf ("\ n");
    } 
    }
}

J'ai modifié le source pour cela (voir l'extrait suivant ci-dessous), ce qui me permet d'avoir une copie de la sortie sur stderr. Cette sortie, je suis capable de rediriger:

 // dans le fichier test.c

static void print_events (Display * dpy)
{
    Événement XEvent;

    tandis que (1) {
    XNextEvent (dpy, & Event);

    // [... d'autres types d'événements sont omniprés ici ...]

        if ((Event.type == key_press_type) ||
           (Event.type == key_release_type)) {
        boucle int;
        XDeviceKeyEvent * key = (XDeviceKeyEvent *) & Event;

        printf ("clé% s% d", (Event.type == key_release_type)? "release": "appuyez sur", clé-> code de touche);
        fprintf (stderr, "clé% s% d", (type d'événement == clé_release_type)? "release": "presse", clé-> code clé);

        for (loop = 0; loopaxes_count; loop ++) {
        printf ("a [% d] =% d", clé-> first_axis + boucle, clé-> axis_data [boucle]);
        }
        printf ("\ n");
    } 
    }
}

Mon idée actuelle est que, peut-être qu'en faisant la redirection, le programme perd sa capacité à surveiller les événements d'activation de touche.

C'est simplement que lorsque stdout n'est pas un terminal, la sortie est mise en mémoire tampon.

Et lorsque vous appuyez sur Ctrl-C, ce tampon est perdu en tant que / s'il n'a pas encore été écrit.

Vous obtenez le même comportement avec n'importe quoi en utilisant stdio. Essayez par exemple:

grep . > file

Entrez quelques lignes non vides et appuyez sur Ctrl-C, vous verrez que le fichier est vide.

D'autre part, tapez:

xinput test 10 > file

Et tapez suffisamment sur le clavier pour que la mémoire tampon soit pleine (au moins 4 Ko de sortie), et vous verrez la taille du fichier augmenter de 4 k à la fois.

Avec grep, vous pouvez taper Ctrl-Dfor greppour sortir normalement après avoir vidé son tampon. Car xinput, je ne pense pas qu'il existe une telle option.

Notez que, par défaut, stderrn’est pas tamponné, ce qui explique pourquoi vous obtenez un comportement différent avecfprintf(stderr)

Si, dans xinput.c, vous ajoutez un signal(SIGINT, exit), c'est-à-dire que vous dites xinputde quitter normalement lorsqu'il reçoit SIGINT, vous verrez qu'il filen'est plus vide (en supposant qu'il ne se bloque pas, car appeler des fonctions de bibliothèque à partir de gestionnaires de signaux n'est pas garanti. Cela peut arriver si le signal arrive pendant que printf écrit dans le tampon).

Si elle est disponible, vous pouvez utiliser la stdbufcommande pour modifier le stdiocomportement de mise en mémoire tampon:

stdbuf -oL xinput test 10 > file

Il existe de nombreuses questions sur ce site qui traitent de la désactivation de la mise en mémoire tampon de type stdio où vous trouverez encore plus de solutions alternatives.

Une commande peut directement écrire pour /dev/ttyempêcher la redirection habituelle.

$ cat demo
#!/bin/ksh
LC_ALL=C TZ=Z date > /dev/tty
$ ./demo >demo.out 2>demo.err
Fri Dec 28 10:31:57  2012
$ ls -l demo*
-rwxr-xr-x 1 jlliagre jlliagre 41 2012-12-28 11:31 demo
-rw-r--r-- 1 jlliagre jlliagre  0 2012-12-28 11:31 demo.err
-rw-r--r-- 1 jlliagre jlliagre  0 2012-12-28 11:31 demo.out

Il semble que la xinputsortie d'un fichier soit rejetée, mais pas celle d'un terminal. Pour ce faire, xinpututilisez probablement l'appel système

int isatty(int fd)

vérifier si le FileScriptor à ouvrir fait référence à un terminal ou non.

Je suis tombé sur le même phénomène il y a un moment avec un programme appelé dpic. Après avoir jeté un œil sur le code source et un peu de débogage, j’ai supprimé les lignes associées isattyet tout a fonctionné comme prévu à nouveau.

Mais je suis d'accord avec vous que cette expérience est très dérangeante;)

Dans votre test.cfichier, vous pouvez vider les données mises en mémoire tampon (void)fflush(stdout);directement après vos printfdéclarations.

    // in test.c
    printf("key %s %d ", (Event.type == key_release_type) ? "release" : "press  ", key->keycode);
    //fprintf(stderr,"key %s %d ", (Event.type == key_release_type) ? "release" : "press  ", key->keycode);
    //(void)fflush(NULL);
    (void)fflush(stdout);

Sur la ligne de commande, vous pouvez activer la sortie avec mise xinput test 10en tampon de ligne en exécutant la commande dans un pseudo-terminal (pty) script.

script -q /dev/null xinput test 10 > file      # FreeBSD, Mac OS X
script -c "xinput test 10" /dev/null > file    # Linux

Oui. Je l'ai même fait dans DOS-times quand j'ai programmé en pascal. Je suppose que le principe est toujours valable:

1. Fermer la sortie
2. Rouvrez stdout en tant que console
3. Ecrire la sortie sur stdout

Cela a cassé des tuyaux.