What exactly happen after pressing Ctrl-C in Linux terminal？

$ gcc foo.c && ./a.out

int main(){
  while(1)
  ;
}

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

int main() {
  int ret = fork();
  while (1)
    ;
}

./a.out & # running in background
ps -o comm,pgid,sid,pid,ppid
COMMAND            PGID     SID     PID    PPID
bash                519     519     519     518
a.out               867     519     867     519
a.out               867     519     868     867
ps                  870     519     870     519

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
int main() {
  int ret = fork();
  if (ret == 0) {
    printf("child process pid:%d pgid:%d\n", getpid(), getpgid(0));
    if (setpgid(0, 0)) {
      perror("setpgid");
      exit(EXIT_FAILURE);
    }
    printf("child process pgid:%d\n", getpgid(0));

    exit(EXIT_SUCCESS);

  } else {
    printf("parent process pid:%d pgid:%d\n", getpid(), getpgid(0));
    exit(EXIT_SUCCESS);
  }
}

$ ./a.out
parent process pid:1262 pgid:1262
child process pid:1263 pgid:1262
child process pgid:1263

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
int main() {
  int ret = 0;

  ret = setsid();
  if (ret) {
    puts("expected to fail");
  }

  ret = fork();
  if (ret) {
    exit(EXIT_SUCCESS);
  } else {
    printf("sid:%d pid:%d pgid:%d before setsid\n", getsid(0), getpid(),
           getpgid(0));
    ret = setsid();
    if (ret == -1) {
      perror("setsid");
      exit(EXIT_FAILURE);
    }
    printf("sid:%d pid:%d pgid:%d after setsid\n", getsid(0), getpid(),
           getpgid(0));
    exit(EXIT_SUCCESS);
  }
}

$ ./a.out
expected to fail
sid:969 pid:2073 pgid:2072 before setsid
sid:2073 pid:2073 pgid:2073 after setsid

$ tty
/dev/pts/2

$ readlink /proc/self/fd/0
/dev/pts/0

$ echo hello world >> /dev/pts/0
hello world

 echo hello world >> /dev/pts/1

#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <unistd.h>
#include <wait.h>
void sigint_handler(int sig) {
  printf("receive SIGINT\n");
  exit(EXIT_SUCCESS);
}

int main() {

  int ret = fork();
  if (ret == -1) {
    perror("fork");
    exit(EXIT_FAILURE);
  }
  if (ret != 0) {
    exit(EXIT_SUCCESS);
  }
  struct sigaction act;
  act.sa_sigaction = NULL;
  act.sa_flags = 0;
  act.sa_handler = sigint_handler;
  sigemptyset(&act.sa_mask);

  ret = sigaction(SIGINT, &act, NULL);
  if (ret) {
    perror("sigaction");
    exit(EXIT_FAILURE);
  }

  printf("old session id:%d parent pid:%d\n", getsid(0), getppid());

  pid_t new_session_id = setsid();
  if (new_session_id == -1) {
    perror("setsid");
    exit(EXIT_FAILURE);
  }
  printf("new session id:%d\n", new_session_id);

  printf("process id:%d\n", getpid());

  int buf[100];
  char terminal[] = "/dev/pts/3";
  int fd = open(terminal, O_RDONLY);

  if (fd == -1) {
    perror("open");
    exit(EXIT_FAILURE);
  }
  // meaningless,just to show the usage
  ret = ioctl(fd, TIOCSCTTY, 1);
  if (ret != 0) {
    perror("ioctl");
    exit(EXIT_FAILURE);
  }

  puts("successfully get the controlling terminal\n");
  pid_t foreground_pgid = tcgetpgrp(fd);
  printf("foreground pgid %d cur pgid %d\n", foreground_pgid, getpgid(0));
  pid_t p = getpid();
  ret = ioctl(fd, TIOCSPGRP, &p);
  if (ret != 0) {
    perror("ioctl");
    exit(EXIT_FAILURE);
  }
  ret = fork();
  if (ret) {
    if (tcsetpgrp(fd, ret)) {
      perror("tcsetpgrp");
      exit(EXIT_FAILURE);
    }
    wait(NULL);
    // not equal(expected)
    printf("current foreground pgid:%d current process pgid:%d\n",
           tcgetpgrp(fd), getpgid(0));
    printf("child return\nparent process enter endless loop\n");
    // can not send SIGINT from another terminal,because foreground process
    // group is not the current process group.
    while (1)
      ;
  }
  setpgid(0, 0);
  printf("child foreground pgid %d cur pgid %d\n", tcgetpgrp(fd), getpgid(0));
  printf("Now in %s\n", terminal);

  while (1) {
    sleep(1);
    printf("continue...\n");
  }

  return 0;
}

static struct input_handler kbd_handler = {
	.event		= kbd_event,
	.match		= kbd_match,
	.connect	= kbd_connect,
	.disconnect	= kbd_disconnect,
	.start		= kbd_start,
	.name		= "kbd",
	.id_table	= kbd_ids,
};

int __init kbd_init(void)
{
	int i;
	int error;

	for (i = 0; i < MAX_NR_CONSOLES; i++) {
		kbd_table[i].ledflagstate = kbd_defleds();
		kbd_table[i].default_ledflagstate = kbd_defleds();
		kbd_table[i].ledmode = LED_SHOW_FLAGS;
		kbd_table[i].lockstate = KBD_DEFLOCK;
		kbd_table[i].slockstate = 0;
		kbd_table[i].modeflags = KBD_DEFMODE;
		kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
	}

	kbd_init_leds();

	error = input_register_handler(&kbd_handler);
	if (error)
		return error;

	tasklet_enable(&keyboard_tasklet);
	tasklet_schedule(&keyboard_tasklet);

	return 0;
}
// omit code here
static void put_queue(struct vc_data *vc, int ch)
{
	tty_insert_flip_char(&vc->port, ch, 0);
	tty_flip_buffer_push(&vc->port);
}

static void puts_queue(struct vc_data *vc, const char *cp)
{
	tty_insert_flip_string(&vc->port, cp, strlen(cp));
	tty_flip_buffer_push(&vc->port);
}

/**
 * tty_flip_buffer_push		-	push terminal buffers
 * @port: tty port to push
 *
 * Queue a push of the terminal flip buffers to the line discipline. Can be
 * called from IRQ/atomic context.
 *
 * In the event of the queue being busy for flipping the work will be held off
 * and retried later.
 */
void tty_flip_buffer_push(struct tty_port *port)
{
	struct tty_bufhead *buf = &port->buf;

	tty_flip_buffer_commit(buf->tail);
	queue_work(system_unbound_wq, &buf->work);
}

// omit code here

/**
 * flush_to_ldisc		-	flush data from buffer to ldisc
 * @work: tty structure passed from work queue.
 *
 * This routine is called out of the software interrupt to flush data from the
 * buffer chain to the line discipline.
 *
 * The receive_buf() method is single threaded for each tty instance.
 *
 * Locking: takes buffer lock to ensure single-threaded flip buffer 'consumer'.
 */
static void flush_to_ldisc(struct work_struct *work)
{
	struct tty_port *port = container_of(work, struct tty_port, buf.work);
	struct tty_bufhead *buf = &port->buf;

	mutex_lock(&buf->lock);

	while (1) {
		struct tty_buffer *head = buf->head;
		struct tty_buffer *next;
		size_t count, rcvd;

		/* Ldisc or user is trying to gain exclusive access */
		if (atomic_read(&buf->priority))
			break;

		/* paired w/ release in __tty_buffer_request_room();
		 * ensures commit value read is not stale if the head
		 * is advancing to the next buffer
		 */
		next = smp_load_acquire(&head->next);
		/* paired w/ release in __tty_buffer_request_room() or in
		 * tty_buffer_flush(); ensures we see the committed buffer data
		 */
		count = smp_load_acquire(&head->commit) - head->read;
		if (!count) {
			if (next == NULL)
				break;
			buf->head = next;
			tty_buffer_free(port, head);
			continue;
		}

		rcvd = receive_buf(port, head, count);
		head->read += rcvd;
		if (rcvd < count)
			lookahead_bufs(port, head);
		if (!rcvd)
			break;

		if (need_resched())
			cond_resched();
	}

	mutex_unlock(&buf->lock);

}

static void __isig(int sig, struct tty_struct *tty)
{
	struct pid *tty_pgrp = tty_get_pgrp(tty);
	if (tty_pgrp) {
		kill_pgrp(tty_pgrp, sig, 1);
		put_pid(tty_pgrp);
	}
}

static void
n_tty_receive_signal_char(struct tty_struct *tty, int signal, u8 c)
{
	isig(signal, tty);
	if (I_IXON(tty))
		start_tty(tty);
	if (L_ECHO(tty)) {
		echo_char(c, tty);
		commit_echoes(tty);
	} else
		process_echoes(tty);
}

if (L_ISIG(tty)) {
		if (c == INTR_CHAR(tty)) {
			n_tty_receive_signal_char(tty, SIGINT, c);
			return;
		} else if (c == QUIT_CHAR(tty)) {
			n_tty_receive_signal_char(tty, SIGQUIT, c);
			return;
		} else if (c == SUSP_CHAR(tty)) {
			n_tty_receive_signal_char(tty, SIGTSTP, c);
			return;
		}
	}