Program Execution with exec()

/*
 * basic_exec.c — exec family — execl, execlp, execv, execvp variants
 *
 * Key concepts: exec replaces process image, 'l' vs 'v', 'p' for PATH search
 * Compile: gcc -o exec basic_exec.c
 * Run:     ./prog
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>



int main() {
    printf("\n");
    printf("========================================\n");
    printf("  exec family — execl, execlp, execv\n");
    printf("========================================\n\n");
    const int EXAMPLE = 1;

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(1);
    }

    if (pid == 0)
    {
        printf("[Child  PID %d] About to call exec — this process image will be REPLACED.\n\n", getpid());
        int status;
        switch (EXAMPLE)
        {
        case 1:
            printf("[Child] Using execl(\"/bin/ls\", \"ls\", \"-l\", NULL)\n");
            printf("        'l' = list arguments, no 'p' = full path required\n\n");
            status = execl("/bin/ls" ,"ls", "-l", NULL);
            break;
        case 2:
            printf("[Child] Using execv(\"/bin/ls\", args)\n");
            printf("        'v' = vector (char* array), no 'p' = full path required\n\n");
            char *args[] = {"ls", "-l", NULL};
            status = execv("/bin/ls", args);
            break;

        default:
            break;
        }
        if (status == -1) {
            perror("[Child] exec failed");
            exit(1);
        }

    }
    else {
        printf("[Parent PID %d] Created child PID %d. Waiting...\n", getpid(), pid);
        wait(NULL);
        printf("[Parent PID %d] Child finished. exec replaced its entire process image.\n\n", getpid());
        printf("========================================\n");
    }

    return 0;
}

/*
 * calculator.c — Calculator child program (used by calculator_exec.c)
 *
 * Key concepts: This is the child program that exec launches
 * Compile: gcc -o calculator calculator.c
 * Run:     ./prog
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>    // for getpid()

int main(int argc, char *argv[]) {
    printf("\n");
    printf("========================================\n");
    printf("  Calculator (exec'd child process)\n");
    printf("========================================\n\n");
    printf("[Calculator PID %d] Launched by parent via exec().\n", getpid());
    printf("[Calculator] Received %d arguments (expected 3: num op num)\n\n", argc - 1);
    if (argc != 4) {
        fprintf(stderr, "Usage: %s <num1> <operator> <num2>\n", argv[0]);
        return 1;
    }

    // Parse arguments
    int num1 = atoi(argv[1]);
    char operator = argv[2][0];
    int num2 = atoi(argv[3]);
    int result = 0;

    // Perform calculation based on the operator
    switch (operator) {
        case '+':
            result = num1 + num2;
            break;
        case '-':
            result = num1 - num2;
            break;
        case '*':
            result = num1 * num2;
            break;
        case '/':
            if (num2 == 0) {
                fprintf(stderr, "Error: Division by zero\n");
                return 1;
            }
            result = num1 / num2;
            break;
        default:
            fprintf(stderr, "Error: Invalid operator '%c'\n", operator);
            return 1;
    }

    printf("[Calculator] %d %c %d = %d\n\n", num1, operator, num2, result);
    printf("========================================\n");
    return 0;
}

/*
 * calculator_exec.c — Parent program that fork+exec's the calculator
 *
 * Key concepts: fork+exec pattern, parent passes args to child via exec
 * Compile: gcc -o calc_exec calculator_exec.c
 * Run:     ./prog
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main() {
    printf("\n");
    printf("========================================\n");
    printf("  fork() + exec() — Launch Calculator\n");
    printf("========================================\n\n");
    printf("[Parent PID %d] Will fork, then exec the calculator program.\n\n", getpid());
    const int EXAMPLE = 1;

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork failed");
        exit(1);
    }

    if (pid == 0) {
        printf("[Child  PID %d] Replacing myself with ./calculator via exec...\n", getpid());
        int status;

        switch (EXAMPLE) {
            case 1: {
                // Using execl: Pass arguments as separate strings
                status = execl("./calculator", "calculator", "5", "+", "3", NULL);
                break;
            }
            case 2: {
                // Using execv: Pass arguments as a char array
                char *args[] = {"calculator", "8", "*", "4", NULL};
                status = execv("./calculator", args);
                break;
            }
            default:
                fprintf(stderr, "Invalid EXAMPLE value\n");
                exit(1);
        }

        if (status == -1) {
            perror("exec failed");
            exit(1);
        }
    } else {
        // Parent process
        printf("[Parent PID %d] Waiting for child PID %d to complete...\n", getpid(), pid);
        wait(NULL);
        printf("[Parent PID %d] Child finished. The calculator ran in a separate process.\n\n", getpid());
        printf("========================================\n");
    }

    return 0;
}