web-dev-qa-db-fra.com

Détecter si stdin est un terminal ou un tuyau?

Lorsque j'exécute "python" à partir du terminal sans arguments, cela fait apparaître le Python shell interactif.

Lorsque j'exécute "cat | python "à partir du terminal, il ne lance pas le mode interactif. D'une manière ou d'une autre, sans obtenir aucune entrée, il a détecté qu'il est connecté à un tuyau.

Comment pourrais-je faire une détection similaire en C ou C++ ou Qt?

c++cqtpipestdin
107
Mike McQuaid

Utilisez isatty:

#include <stdio.h>
#include <io.h>
...    
if (isatty(fileno(stdin)))
    printf( "stdin is a terminal\n" );
else
    printf( "stdin is a file or a pipe\n");

(Sur les fenêtres, ils sont préfixés par des traits de soulignement: _isatty, _fileno)

131
RichieHindle

Sommaire

Pour de nombreux cas d'utilisation, la fonction POSIX isatty() est tout ce dont elle a besoin pour détecter si stdin est connecté à un terminal. Un exemple minimal:

#include <unistd.h>
#include <stdio.h>

int main(int argc, char **argv)
{
  if (isatty(fileno(stdin)))
    puts("stdin is connected to a terminal");
  else
    puts("stdin is NOT connected to a terminal");
  return 0;
}

La section suivante compare différentes méthodes qui peuvent être utilisées si différents degrés d'interactivité doivent être testés.

Méthodes en détail

Il existe plusieurs méthodes pour détecter si un programme s'exécute de manière interactive. Le tableau suivant présente un aperçu:

 cmd\méthode ctermid open isatty fstat 
 ――――――――――――――――――――――――――――――――― ――――――――――――――――――――――――――― 
 ./ test/dev/tty OK OUI S_ISCHR 
 ./ test ≺ test.cc/dev/tty OK NON S_ISREG 
 Cat test.cc | ./test/dev/tty OK NON S_ISFIFO 
 echo ./test | at now/dev/tty FAIL NO S_ISREG

Les résultats proviennent d'un système Ubuntu Linux 11.04 utilisant le programme suivant:

#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
#include <unistd.h>
#include <iostream>
using namespace std;
int main() {
  char tty[L_ctermid+1] = {0};
  ctermid(tty);
  cout << "ID: " << tty << '\n';
  int fd = ::open(tty, O_RDONLY);
  if (fd < 0) perror("Could not open terminal");
  else {
    cout << "Opened terminal\n";
    struct termios term;
    int r = tcgetattr(fd, &term);
    if (r < 0) perror("Could not get attributes");
    else cout << "Got attributes\n";
  }
  if (isatty(fileno(stdin))) cout << "Is a terminal\n";
  else cout << "Is not a terminal\n";
  struct stat stats;
  int r = fstat(fileno(stdin), &stats);
  if (r < 0) perror("fstat failed");
  else {
    if (S_ISCHR(stats.st_mode)) cout << "S_ISCHR\n";
    else if (S_ISFIFO(stats.st_mode)) cout << "S_ISFIFO\n";
    else if (S_ISREG(stats.st_mode)) cout << "S_ISREG\n";
    else cout << "unknown stat mode\n";
  }
  return 0;
}

Dispositif terminal

Si la session interactive nécessite certaines fonctionnalités, vous pouvez ouvrir le terminal et définir (temporairement) les attributs de terminal dont vous avez besoin via tcsetattr().

Exemple Python

Le code Python qui décide si l'interpréteur s'exécute de manière interactive utilise isatty(). La fonction PyRun_AnyFileExFlags()

/* Parse input from a file and execute it */

int
PyRun_AnyFileExFlags(FILE *fp, const char *filename, int closeit,
                     PyCompilerFlags *flags)
{
    if (filename == NULL)
        filename = "???";
    if (Py_FdIsInteractive(fp, filename)) {
        int err = PyRun_InteractiveLoopFlags(fp, filename, flags);

appelle Py_FdIsInteractive()

/*
 * The file descriptor fd is considered ``interactive'' if either
 *   a) isatty(fd) is TRUE, or
 *   b) the -i flag was given, and the filename associated with
 *      the descriptor is NULL or "<stdin>" or "???".
 */
int
Py_FdIsInteractive(FILE *fp, const char *filename)
{
    if (isatty((int)fileno(fp)))
        return 1;

qui appelle isatty().

Conclusion

Il existe différents degrés d'interactivité. Pour vérifier si stdin est connecté à un tube/fichier ou à un vrai terminal isatty() est une méthode naturelle pour le faire.

64
maxschlepzig

Appelez stat () ou fstat () et voyez si S_IFIFO est défini dans st_mode.

3
sigjuice

Ils vérifient probablement le type de fichier que "stdin" est avec fstat, quelque chose comme ceci:

struct stat stats;
fstat(0, &stats);
if (S_ISCHR(stats.st_mode)) {
    // Looks like a tty, so we're in interactive mode.
} else if (S_ISFIFO(stats.st_mode)) {
    // Looks like a pipe, so we're in non-interactive mode.
}

Bien sûr Python est open source, vous pouvez donc simplement regarder ce qu'ils font et savoir avec certitude:

http://www.python.org/ftp/python/2.6.2/Python-2.6.2.tar.bz2

3
Eric Melski

Sous Windows, vous pouvez utiliser GetFileType.

HANDLE hIn = GetStdHandle(STD_INPUT_HANDLE);
DWORD type = GetFileType(hIn);
switch (type) {
case FILE_TYPE_CHAR: 
    // it's from a character device, almost certainly the console
case FILE_TYPE_DISK:
    // redirected from a file
case FILE_TYPE_PIPE:
    // piped from another program, a la "echo hello | myprog"
case FILE_TYPE_UNKNOWN:
    // this shouldn't be happening...
}
2
Glen Knowles

Vous pouvez appeler stat(0, &result) et rechercher !S_ISREG( result.st_mode ). C'est Posix, pas C/C++, cependant.

2
Marc Mutz - mmutz