The simplest question you can ask is: “Is fd 1 (stdout) actually a terminal, or has it been redirected to a file?” The isatty() function answers this.

When the return value is 0, check errno — it will be set to ENOTTY if the fd is valid but not a terminal, or EBADF if the fd is not a valid open file descriptor.

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

int main(void)
{
    /* Check each standard file descriptor */
    printf("stdin  (fd 0): %s\n",
           isatty(STDIN_FILENO)  ? "IS a terminal"  : "NOT a terminal");
    printf("stdout (fd 1): %s\n",
           isatty(STDOUT_FILENO) ? "IS a terminal"  : "NOT a terminal");
    printf("stderr (fd 2): %s\n",
           isatty(STDERR_FILENO) ? "IS a terminal"  : "NOT a terminal");
    return 0;
}

Testing with redirection:

gcc -o isatty_demo isatty_demo.c
./isatty_demo
# stdin  (fd 0): IS a terminal
# stdout (fd 1): IS a terminal
# stderr (fd 2): IS a terminal

./isatty_demo > /tmp/out.txt
# (stdout goes to file)
# stdin  (fd 0): IS a terminal
# stderr (fd 2): IS a terminal
# (stdout line goes to file, says NOT a terminal)

echo "hello" | ./isatty_demo
# stdin  (fd 0): NOT a terminal   <-- piped, not a terminal

Real-world use case:

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

void print_colored(const char *msg)
{
    if (isatty(STDOUT_FILENO)) {
        /* stdout is a real terminal, use ANSI color codes */
        printf("\033[1;32m%s\033[0m\n", msg);   /* green */
    } else {
        /* stdout is redirected to file/pipe, no color codes */
        printf("%s\n", msg);
    }
}

int main(void)
{
    print_colored("Build successful!");
    return 0;
}

Once you know that a file descriptor is connected to a terminal, you might also want to know which terminal — for example /dev/pts/3 or /dev/tty1. The ttyname() function returns this path as a string.

Important: The string returned is statically allocated. This means it lives in a fixed buffer inside the C library. If you call ttyname() again, the new result overwrites the old one. Always copy the result if you need to keep it.

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

int main(void)
{
    char *name;
    char buf[256];

    /* ttyname() for each standard fd */
    for (int fd = 0; fd <= 2; fd++) {
        name = ttyname(fd);
        if (name == NULL) {
            printf("fd %d: not a terminal or error\n", fd);
        } else {
            /* Copy it — static buffer can be overwritten on next call */
            strncpy(buf, name, sizeof(buf) - 1);
            printf("fd %d: terminal = %s\n", fd, buf);
        }
    }
    return 0;
}

# Typical output when running in a terminal emulator:
# fd 0: terminal = /dev/pts/3
# fd 1: terminal = /dev/pts/3
# fd 2: terminal = /dev/pts/3

Because ttyname() uses a static buffer, it is not thread-safe. If two threads call it simultaneously, one will overwrite the other’s result. The ttyname_r() function is the reentrant (thread-safe) alternative — you provide your own buffer.

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

int main(void)
{
    char buf[256];
    int  ret;

    ret = ttyname_r(STDIN_FILENO, buf, sizeof(buf));
    if (ret != 0) {
        /* ttyname_r returns errno value directly, not -1 */
        fprintf(stderr, "ttyname_r: %s\n", strerror(ret));
        return 1;
    }

    printf("stdin is connected to: %s\n", buf);
    return 0;
}

Every process has a controlling terminal — the terminal that was associated with the session when the session leader opened a terminal. The ctermid() function returns the path name of this controlling terminal. On Linux (and most UNIX systems) this is always /dev/tty.

#include <stdio.h>

int main(void)
{
    char buf[L_ctermid];   /* L_ctermid is the max size, defined in stdio.h */
    char *name;

    /* Pass a buffer to avoid static allocation */
    name = ctermid(buf);

    printf("Controlling terminal: %s\n", name);
    return 0;
}
/* Output: Controlling terminal: /dev/tty */

If you pass NULL to ctermid(), it uses an internal static buffer (not thread-safe). Always pass your own buffer in multi-threaded programs.

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

int main(void)
{
    int tty_fd;
    char buf[L_ctermid];

    ctermid(buf);   /* get controlling terminal path */

    /* Open the controlling terminal directly
       even if stdin/stdout are redirected */
    tty_fd = open(buf, O_RDWR);
    if (tty_fd == -1) {
        perror("open controlling terminal");
        return 1;
    }

    write(tty_fd, "Hello from controlling terminal!\n", 33);
    close(tty_fd);
    return 0;
}

The shell command tty prints the name of the terminal connected to its standard input. It is essentially a command-line wrapper around ttyname(STDIN_FILENO).

# Run in a terminal emulator
tty
# Output: /dev/pts/3

# If stdin is redirected:
tty < /dev/null
# Output: not a tty

# Check in a script
if tty -s; then
    echo "Running in a terminal"
else
    echo "Not in a terminal (piped or redirected)"
fi

The -s (silent) flag makes tty produce no output but sets the exit code: 0 if stdin is a terminal, 1 if not.

Q1. What does isatty() return and what does it check internally?

isatty() returns 1 if the given file descriptor refers to a terminal, 0 otherwise. Internally it calls tcgetattr() on the fd. If tcgetattr() succeeds, the fd is a terminal. If it fails with ENOTTY, the fd is not a terminal. errno is set to ENOTTY when the fd is valid but not a terminal.

Q2. Why is ttyname() not thread-safe, and what is the alternative?

ttyname() stores the result in a static internal buffer. If two threads call it at the same time, the second call overwrites the first thread’s result, causing a race condition. The alternative is ttyname_r(), which takes a caller-provided buffer so each thread can have its own copy of the result.

Q3. How does ttyname() find the terminal device name?

It uses fstat() to get the device ID (st_rdev) of the file descriptor, then walks through /dev and /dev/pts using opendir() / readdir(), calling stat() on each entry and comparing its st_rdev. When it finds a match, that entry’s path is returned.

Q4. What is /dev/tty and when would you open it directly?

/dev/tty is a special device file that always refers to the calling process’s controlling terminal. You open it directly when you need to interact with the user’s terminal even though stdin/stdout may have been redirected. The classic example is getpass(), which opens /dev/tty to display a password prompt and read the password without interfering with piped input/output.

Q5. What is the difference between ttyname() and ctermid()?

ttyname(fd) takes a specific file descriptor and returns the device path of whichever terminal that fd is connected to. ctermid() takes no fd argument and always returns the path of the process’s controlling terminal, which on Linux is always /dev/tty. They answer different questions: “which terminal is this fd?” vs. “which terminal does this process control?”

Q6. What directories does ttyname() search for terminal entries?

It searches /dev (for virtual consoles like /dev/tty1 and BSD-style pseudoterminals) and /dev/pts (for System V-style pseudoterminal slave devices used by modern terminal emulators).

Q7. What does the tty(1) command do?

The tty command prints the name of the terminal connected to its standard input. It is essentially the command-line equivalent of calling ttyname(STDIN_FILENO). With the -s flag it runs silently and returns exit code 0 if stdin is a terminal, 1 if not.

Q8. How would you write a program that always outputs to the terminal even if stdout is redirected?

Open /dev/tty (using ctermid() to get the path portably) with open(O_RDWR) and write directly to that file descriptor. This bypasses the stdout redirection and always reaches the controlling terminal.