// doublefree.c — liberar dos veces el mismo bloque.
// Sin valgrind, glibc suele abortar: "free(): double free detected".
//   valgrind ./doublefree
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static void cleanup(char *buf) {
    free(buf);
}

int main(void) {
    char *buf = malloc(32);
    if (buf == NULL)
        return 1;
    strcpy(buf, "hola");
    printf("%s\n", buf);
    cleanup(buf);
    free(buf);   // segundo free del mismo bloque
    return 0;
}

// layout.c — dónde viven el código, los datos, el heap y la pila.
// Imprime direcciones (virtuales) de cada región del espacio de direcciones.
//   ./layout              (con ASLR: cambian en cada ejecución)
//   setarch -R ./layout   (sin ASLR: siempre las mismas)
#define _DEFAULT_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>

int global_init = 42;   // datos inicializados (.data)
int global_zero;        // datos en cero (.bss)

int main(void) {
    int local = 7;                       // en la pila
    int *small = malloc(16);             // heap (vía brk)
    int *big = malloc(1 << 20);          // 1 MiB: glibc usa mmap
    void *brk_end = sbrk(0);             // fin actual del heap

    printf("código  main()       %p\n", (void *)main);
    printf("datos   global_init  %p\n", (void *)&global_init);
    printf("bss     global_zero  %p\n", (void *)&global_zero);
    printf("heap    malloc(16)   %p\n", (void *)small);
    printf("heap    sbrk(0)      %p\n", brk_end);
    printf("mmap    malloc(1MiB) %p\n", (void *)big);
    printf("pila    local        %p\n", (void *)&local);

    free(big);
    free(small);
    return 0;
}

// leak.c — fuga de memoria (memory leak).
// Reserva 10 bloques de 64 bytes y nunca los libera.
//   valgrind --leak-check=full ./leak
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static char *make_label(int i) {
    char *s = malloc(64);
    if (s == NULL)
        exit(1);
    snprintf(s, 64, "etiqueta %d", i);
    return s;
}

int main(void) {
    for (int i = 0; i < 10; i++) {
        char *label = make_label(i);
        printf("%s\n", label);
        // falta free(label): el puntero se pierde en cada vuelta
    }
    return 0;
}

// uaf.c — uso después de liberar (use-after-free).
// p queda como puntero colgante (dangling pointer) tras free().
//   valgrind ./uaf
#include <stdio.h>
#include <stdlib.h>

struct account {
    int id;
    int balance;
};

static void close_account(struct account *a) {
    free(a);   // libera, pero el llamador conserva el puntero
}

int main(void) {
    struct account *a = malloc(sizeof(*a));
    if (a == NULL)
        return 1;
    a->id = 1;
    a->balance = 100;
    close_account(a);
    printf("saldo: %d\n", a->balance);   // lectura de memoria liberada
    return 0;
}

// uninit.c — lectura de memoria no inicializada.
// malloc() no pone la memoria en cero (calloc() sí).
//   valgrind --track-origins=yes ./uninit
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int n = 8;
    int *v = malloc(n * sizeof(int));
    if (v == NULL)
        return 1;
    for (int i = 0; i < n - 1; i++)   // error: falta v[n-1]
        v[i] = i;

    int sum = 0;
    for (int i = 0; i < n; i++)
        sum += v[i];
    if (sum > 28)                      // la decisión depende de basura
        printf("suma grande: %d\n", sum);
    else
        printf("suma: %d\n", sum);
    free(v);
    return 0;
}

CFLAGS = -Wall -Wextra -g
PROGS  = layout leak uaf uninit doublefree
BUGS   = leak uaf uninit doublefree
VG     = valgrind --leak-check=full --track-origins=yes

all: $(PROGS)

# Ejecuta cada programa con errores bajo valgrind. Algunos abortan
# sin valgrind (doublefree), por eso se ignora el código de salida.
check: $(BUGS)
	@for p in $(BUGS); do echo "=== $$p ==="; $(VG) ./$$p; true; done

clean:
	rm -f $(PROGS) vgcore.*

.PHONY: all check clean