How to capture Control+D signal?


C Problem Overview

I want to capture the Ctrl+D signal in my program and write a signal handler for it. How can I do that? I am working on C and using a Linux system.

C Solutions

Solution 1 - C

As others have already said, to handle Control+D, handle "end of file"s.

Control+D is a piece of communication between the user and the pseudo-file that you see as stdin. It does not mean specifically "end of file", but more generally "flush the input I typed so far". Flushing means that any read() call on stdin in your program returns with the length of the input typed since the last flush. If the line is nonempty, the input becomes available to your program although the user did not type "return" yet. If the line is empty, then read() returns with zero, and that is interpreted as "end of file".

So when using Control+D to end a program, it only works at the beginning of a line, or if you do it twice (first time to flush, second time for read() to return zero).

Try it:

$ cat
   (type Control-D once)
foofoo (read has returned "foo")
   (type Control-D again)

Solution 2 - C

Ctrl+D is not a signal, it's EOF (End-Of-File). It closes the stdin pipe. If read(STDIN) returns 0, it means stdin closed, which means Ctrl+D was hit (assuming there is a keyboard at the other end of the pipe).

Solution 3 - C

A minimalistic example:

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

void sig_hnd(int sig){ (void)sig; printf("(VINTR)"); }

int main(){

struct termios old_termios, new_termios;

signal( SIGINT, sig_hnd );

new_termios             = old_termios;
new_termios.c_cc[VEOF]  = 3; // ^C
new_termios.c_cc[VINTR] = 4; // ^D

char line[256]; int len;
len=read(0,line,256); line[len]='\0';
if( len <0 ) printf("(len: %i)",len);
if( len==0 ) printf("(VEOF)");
if( len >0 ){
if( line[len-1] == 10 ) printf("(line:'%.*s')\n",len-1,line);
if( line[len-1] != 10 ) printf("(partial line:'%s')",line);
}while( line[0] != 'q' );


tcsetattr(0,TCSANOW,&old_termios); }

The program change the VEOF char (from Ctrl-D) to Ctrl-C and the VINTR char (from Ctrl-C) to Ctrl-D. If You press Ctrl-D then the terminal driver will send a SIGINT to the signal handler of the program.

Note: pressing VINTR will erase the terminal input buffer so You can not read the characters typed in the line before the VINTR key pressed.

Solution 4 - C

There's no need to process signals.

You need to ensure ISIG is not set on the terminal flags, that's all.

Here's a complete contained example using select to avoid blocking on stdin:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <time.h>
#include <sys/select.h>

#define STDIN_FILENO 0

struct termios org_opts;

/** Select to check if stdin has pending input */
int pending_input(void) {
  struct timeval tv;
  fd_set fds;
  tv.tv_sec = 0;
  tv.tv_usec = 0;
  select(STDIN_FILENO+1, &fds, NULL, NULL, &tv);
  return FD_ISSET(STDIN_FILENO, &fds);

/** Input terminal mode; save old, setup new */
void setup_terminal(void) {
  struct termios new_opts;
  tcgetattr(STDIN_FILENO, &org_opts);
  memcpy(&new_opts, &org_opts, sizeof(new_opts));
  new_opts.c_lflag &= ~(ICANON | ECHO | ECHOE | ECHOK | ECHONL | ECHOPRT | ECHOKE | ISIG | ICRNL);
  tcsetattr(STDIN_FILENO, TCSANOW, &new_opts);

/** Shutdown terminal mode */
void reset_terminal(void) {
  tcsetattr(STDIN_FILENO, TCSANOW, &org_opts);

/** Return next input or -1 if none */
int next_input(void) {
  if (!pending_input())
    return -1;
  int rtn = fgetc(stdin);
  printf("Found: %d\n", rtn);

int main()

  printf("Press Q to quit...\n");
  for (;;) {
    int key = next_input();
    if (key != -1) {
      if ((key == 113) || (key == 81)) {
        printf("\nNormal exit\n");

  return 0;


doug-2:rust-sys-sterm doug$ cc junk.c
doug-2:rust-sys-sterm doug$ ./a.out
Press Q to quit...
Found: 4
Found: 3
Found: 27
Found: 26
Found: 113

Normal exit

NB. 3 is control C and 4 is control D; 26 is control z. 113 is 'q'. See: for a full table.

Solution 5 - C

As far as I know Ctrl+D is translated by the system to end of standard input so your app won't get any signal.

I think that the only way to intercept Ctrl+D is to work directly with the system api (like accessing tty)

Solution 6 - C

You can use poll() and watch for POLLHUP on fd #1, because the TTY layer translates ^D to EOF.

Solution 7 - C

Ctrl + D value in ascci table is 4 and is a non printable characters.
So your can capture it in a terminal with the following code. When getline function get Ctrl + D an error occur and return value is -1. Your can make a condition on the return value.

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

int main(void)
    char *buf = malloc(sizeof(char) * 500);
    size_t size = 500;
    int nb = getline(&buf, &size, stdin);
    if (nb == -1)
        printf("CTRL + D captured\n");
    return (0);

Solution 8 - C

You can check if stdin is not of with the feof method like so:

if (feof(stdin))
    // some code

See this for more details/


All content for this solution is sourced from the original question on Stackoverflow.

The content on this page is licensed under the Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license.

Content TypeOriginal AuthorOriginal Content on Stackoverflow
QuestionRyanView Question on Stackoverflow
Solution 1 - CPascal CuoqView Answer on Stackoverflow
Solution 2 - CEtienne DechampsView Answer on Stackoverflow
Solution 3 - CsambowryView Answer on Stackoverflow
Solution 4 - CDougView Answer on Stackoverflow
Solution 5 - CPiotr CzaplaView Answer on Stackoverflow
Solution 6 - Cuser175104View Answer on Stackoverflow
Solution 7 - CGeorg GbessView Answer on Stackoverflow
Solution 8 - C2KAbhishekView Answer on Stackoverflow