#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main(int argc, char **argv, char **env) {
    printf("parent started, pid=%d\n", getpid());

    char *line = NULL;
    size_t len = 0;
    ssize_t read;
    while ((read = getline(&line, &len, stdin)) != -1) {
        pid_t pid = fork();
        if (pid == -1) {
            perror("fork");
            break;
        }

        if (pid == 0) {
            printf("1 fork return in child, pid=%d\n", getpid());
            char *const av[] = {"child", line, NULL};
            if (-1 == execve("./child", av, env)) {
                perror("execve");
                break;
            }
        } else {
            printf("2 fork return in parent, child pid=%d\n", pid);
            int status = 0;
            wait(&status);
        }
    }

    return 0;
}

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

void vuln(char *str) {
    char buf[4];
    strcpy(buf, str);
    printf("child buf: %s", buf);
}

int main(int argc, char **argv) {
    puts("child started");
    vuln(argv[1]);
    return 0;
}

gdb child --pid $parent_pid
(gdb) set follow-fork-mode child
(gdb) b strcpy
Breakpoint 1 at 0x4004c0
(gdb) c
Continuing.
Warning:
Cannot insert breakpoint 1.
Cannot access memory at address 0x4004c0

Command aborted.

gdb child --pid $parent_pid
(gdb) set follow-fork-mode child
(gdb) hb *0x4004c0
Hardware assisted breakpoint 1 at 0x4004c0
(gdb) c
Continuing.
[New process 309]
process 309 is executing new program: /pwn/child

Thread 2.1 "child" received signal SIGABRT, Aborted.
[Switching to process 309]

gdb child --pid $parent_pid
(gdb) set follow-fork-mode child
(gdb) b _start
Breakpoint 1 at 0x7fbfb4c30090

set detach-on-fork on
set follow-fork-mode child
set breakpoint pending on
b _start
attach $parent_pid
file child
continue

set follow-fork-mode child
catch exec

(gdb) help set scheduler-locking
Set mode for locking scheduler during execution.
off    == no locking (threads may preempt at any time)
on     == full locking (no thread except the current thread may run)
          This applies to both normal execution and replay mode.
step   == scheduler locked during stepping commands (step, next, stepi, nexti).
          In this mode, other threads may run during other commands.
          This applies to both normal execution and replay mode.
replay == scheduler locked in replay mode and unlocked during normal execution.

// demo.c
#include <stdio.h>
#include <unistd.h>

int main(int argc, char **argv) {
    int n;
    char buf[10];
    for (int i = 0; i < argc; i++)
        printf("argv[%d] = %s\n", i, argv[i]);

    int nread;
    nread = read(STDIN_FILENO, buf, 10);
    printf("first read: %d\n", nread);
   
    nread = read(STDIN_FILENO, buf, 10);
    printf("second read: %d\n", nread);
    return 0;
}

$ gdb demo
(gdb) run hello world
Starting program: /pwn/demo hello world
argv[0] = /pwn/demo
argv[1] = hello
argv[2] = world

(gdb) set args hello world
(gdb) run
Starting program: /pwn/demo hello world
argv[0] = /pwn/demo
argv[1] = hello
argv[2] = world

$ gdb demo
(gdb) run <file

$ python -c ‘print "A"*100‘ | ./demo

$ gdb demo
(gdb) run < <(python -c ‘print "A"*100‘)
Starting program: /pwn/demo < <(python -c ‘print "A"*100‘)
argv[0] = /pwn/demo
first read: 10
second read: 10

$ gdb demo
(gdb) run <<<$(python -c ‘print "A"*100‘)
Starting program: /pwn/demo <<<$(python -c ‘print "A"*100‘)
argv[0] = /pwn/demo
first read: 10
second read: 10

$ gdb demo
(gdb) run < <(echo -n 1112222)
Starting program: /pwn/demo < <(echo -n 1112222)
argv[0] = /pwn/demo
first read: 7
second read: 0

$ gdb demo
(gdb) run < <(echo -n 111; sleep 1; echo -n 2222)
Starting program: /pwn/demo < <(echo -n 111; sleep 1; echo -n 2222)
argv[0] = /pwn/demo
first read: 3
second read: 4

(gdb) run <<<$(echo -n 111; sleep 1; echo -n 2222)
Starting program: /pwn/demo <<<$(echo -n 111; sleep 1; echo -n 2222)
argv[0] = /pwn/demo
first read: 8
second read: 0

(gdb) help set environment
Set environment variable value to give the program.
Arguments are VAR VALUE where VAR is variable name and VALUE is value.
VALUES of environment variables are uninterpreted strings.
This does not affect the program until the next "run" command.

$ env CONTENT_TYPE="$(python -c "print ‘A‘*10 + ‘\x04\x03\x02\x01‘")" gdb demo
(gdb) run