The Next Digital Crisis
2038

#include <cstdint>
#include <chrono>
#include <cstring>

/*
 * LEGACY save file header — embedded in shipped .sav files worldwide.
 * Cannot change the file format without breaking backwards compat.
 */
#pragma pack(push, 1)
struct LegacySaveHeader_v1 {
    uint32_t magic;
    uint32_t save_time;    // ← 32-bit Unix epoch. BREAKS 2038.
    uint32_t playtime_secs;
    char     player_name[32];
};
#pragma pack(pop)

/* ✅ NEW header — version 2, with 64-bit timestamp and magic bump */
#pragma pack(push, 1)
struct SaveHeader_v2 {
    uint32_t magic;
    uint32_t version;           // = 2
    int64_t  save_time_64;     // ← 64-bit. Safe for 292 billion years.
    uint64_t playtime_ms;       // millisecond precision too
    char     player_name[32];
    uint8_t  padding[4];        // maintain alignment
};
#pragma pack(pop)

/* Migration function: upgrade old save to new format */
SaveHeader_v2 migrate_save_header(const LegacySaveHeader_v1& old) {
    SaveHeader_v2 nw{};
    nw.magic        = old.magic;
    nw.version      = 2;
    /* Extend 32-bit epoch to 64-bit — safe because 2038 hasn't passed yet */
    nw.save_time_64 = static_cast<int64_t>(
        static_cast<uint32_t>(old.save_time)
    );
    nw.playtime_ms  = (uint64_t)old.playtime_secs * 1000;
    memcpy(nw.player_name, old.player_name, 32);
    return nw;
}

/* ✅ Always use this to get current save timestamp */
int64_t get_save_timestamp() {
    using SC = std::chrono::system_clock;
    return std::chrono::duration_cast<std::chrono::seconds>(
        SC::now().time_since_epoch()
    ).count();  // returns int64_t — safe
}

// ❌ TRAP 1: The _USE_32BIT_TIME_T poison flag
// Defining this anywhere in your project reverts time_t to 32-bit
// even on 64-bit Windows. Often lurks in legacy project .vcxproj files.
#define _USE_32BIT_TIME_T   // ← NEVER define this. Ever.
#include <time.h>
// Now sizeof(time_t) == 4 again. You've recreated the 2038 bug manually.

// ✅ CORRECT: Do NOT define _USE_32BIT_TIME_T. Just use time_t normally.
#include <time.h>
// On MSVC 2005+ x64: sizeof(time_t) == 8. Safe.

// ───────────────────────────────────────────────────────────────────

// ❌ TRAP 2: Mixing DLLs compiled with different CRT versions.
// A DLL compiled with MSVC6 (__time32_t) passing time_t to a caller
// compiled with MSVC2019 (__time64_t) causes struct size mismatch.

// In the old DLL (32-bit time_t):
__declspec(dllexport) time_t get_expiry() {
    return time(NULL) + 86400; // returns 4-byte value
}

// In your new code (64-bit time_t):
// Calling get_expiry() reads 8 bytes but DLL only wrote 4 — CORRUPTION.

// ✅ FIX: Recompile ALL DLLs with the same MSVC version.
//         Or use explicit __time64_t in DLL ABI contracts.
__declspec(dllexport) __time64_t get_expiry_safe() {
    return _time64(NULL) + 86400LL; // explicit 64-bit — ABI stable
}

// ───────────────────────────────────────────────────────────────────

// ❌ TRAP 3: Using FILETIME arithmetic incorrectly
FILETIME ft;
GetSystemTimeAsFileTime(&ft);
// ft is two 32-bit DWORDs. Never cast directly to __int64 on unaligned data!
__int64 raw = *(__int64*)&ft;  // ← Undefined behaviour on unaligned access

// ✅ CORRECT: Use ULARGE_INTEGER to safely combine the two DWORDs
ULARGE_INTEGER uli;
uli.LowPart  = ft.dwLowDateTime;
uli.HighPart = ft.dwHighDateTime;
__int64 safe_ft = (__int64)uli.QuadPart; // 64-bit FILETIME. Safe until year 30828.

// ───────────────────────────────────────────────────────────────────

// ✅ BEST PRACTICE on Windows: Use GetSystemTimePreciseAsFileTime (Win8+)
//    + convert to Unix epoch via well-known offset
int64_t windows_unix_epoch_now() {
    FILETIME ft2;
    GetSystemTimePreciseAsFileTime(&ft2);
    ULARGE_INTEGER u;
    u.LowPart  = ft2.dwLowDateTime;
    u.HighPart = ft2.dwHighDateTime;
    // FILETIME epoch is Jan 1, 1601. Unix epoch is Jan 1, 1970.
    // Difference: 11644473600 seconds = 116444736000000000 * 100ns intervals
    return (int64_t)((u.QuadPart - 116444736000000000ULL) / 10000000ULL);
}

/* ❌ BROKEN: Stores time as 32-bit int — overflows 2038 */
#include <time.h>
#include <stdio.h>

void log_event(const char *msg) {
    /* BUG: int is 32-bit — overflows on Jan 19, 2038 */
    int timestamp = (int)time(NULL);

    /* BUG: arithmetic on 32-bit values — overflow during addition */
    int expires = timestamp + (30 * 24 * 3600); // add 30 days

    printf("[%d] %s (expires: %d)\n", timestamp, msg, expires);
}

int main() {
    /* BUG: struct member is int instead of time_t */
    struct Record {
        int created_at;   // ← will silently corrupt post-2038
        char name[64];
    };
    return 0;
}

/* ✅ FIXED: Use time_t throughout — 64-bit on modern systems */
#include <time.h>
#include <stdint.h>
#include <stdio.h>
#include <inttypes.h>   // for PRId64

/* Compile-time assertion: fail loudly if time_t is only 4 bytes */
_Static_assert(sizeof(time_t) >= 8,
    "FATAL: time_t is 32-bit. Compile with -D_TIME_BITS=64 or use 64-bit target.");

void log_event(const char *msg) {
    /* ✅ time_t is the correct type for Unix timestamps */
    time_t timestamp = time(NULL);

    /* ✅ arithmetic stays in time_t — safe for 64-bit range */
    time_t expires = timestamp + (30LL * 24 * 3600);

    /* Use PRId64 or cast explicitly for portable printf */
    printf("[%" PRId64 "] %s (expires: %" PRId64 ")\n",
           (int64_t)timestamp, msg, (int64_t)expires);
}

int main() {
    /* ✅ struct members use time_t, not int */
    struct Record {
        time_t created_at;   // ← 64-bit on properly configured platform
        char name[64];
    };
    return 0;
}

/*
 * For embedded targets where time_t is stuck at 32-bit,
 * we define our own 64-bit epoch type and helper functions.
 * Works on ARM Cortex-M, MIPS, AVR32, etc.
 */
#include <stdint.h>
#include <stdbool.h>

/* Custom 64-bit epoch type — immune to 2038 overflow */
typedef int64_t epoch64_t;

/* ─── RTC hardware read (platform-specific, returns 32-bit) ─── */
extern uint32_t rtc_get_raw32(void);  // platform BSP function

/* Era counter stored in battery-backed SRAM or EEPROM */
static uint32_t rtc_era = 0;
static uint32_t last_raw = 0;

/*
 * epoch64_now() — returns a 64-bit Unix timestamp.
 * Must be called at least once every ~136 years to detect rollover.
 * In practice, call it at every boot and at least every 24h.
 */
epoch64_t epoch64_now(void) {
    uint32_t raw = rtc_get_raw32();

    /* Detect rollover: if raw went backwards, increment era */
    if (raw < last_raw) {
        rtc_era++;
        /* Persist era to non-volatile storage here! */
    }
    last_raw = raw;

    /* Full 64-bit time = (era * 2^32) + raw_seconds */
    return (epoch64_t)((uint64_t)rtc_era << 32) | (uint64_t)raw;
}

/* Convenience: seconds until expiry — safely 64-bit */
int64_t seconds_until(epoch64_t expiry) {
    return (int64_t)(expiry - epoch64_now());
}

/* Example usage */
void check_cert_expiry(epoch64_t cert_expiry) {
    int64_t secs = seconds_until(cert_expiry);
    if (secs <= 0) {
        raise_alert("Certificate expired!");
    } else if (secs < 86400 * 30) {
        raise_alert("Certificate expires within 30 days!");
    }
}

#include <chrono>
#include <cstdint>
#include <iostream>
#include <format>    // C++20

/*
 * std::chrono::system_clock::time_point uses a 64-bit
 * representation internally on all major implementations.
 * This is the idiomatic C++ solution.
 */
namespace SafeTime {

using Clock     = std::chrono::system_clock;
using TimePoint = Clock::time_point;
using Duration  = std::chrono::seconds;

/* Returns current time — never use time(NULL) in C++ */
inline TimePoint now() { return Clock::now(); }

/* Safe duration-to-int64 helper */
inline int64_t to_epoch_s(const TimePoint& tp) {
    return std::chrono::duration_cast<Duration>(
        tp.time_since_epoch()
    ).count();
}

/* Add days safely */
inline TimePoint add_days(const TimePoint& tp, int64_t days) {
    return tp + std::chrono::hours(24 * days);
}

} // namespace SafeTime

int main() {
    auto now       = SafeTime::now();
    auto in30years = SafeTime::add_days(now, 365 * 30);

    // Both values are int64_t — no overflow for billions of years
    std::cout << "Now:       " << SafeTime::to_epoch_s(now)       << "\n";
    std::cout << "In 30yrs:  " << SafeTime::to_epoch_s(in30years) << "\n";

    // Compile-time check: system_clock duration must be 64-bit
    static_assert(
        sizeof(SafeTime::Clock::rep) >= 8,
        "system_clock rep must be at least 64 bits"
    );
    return 0;
}

-- ❌ BROKEN: MySQL TIMESTAMP (32-bit Unix epoch, max 2038-01-19)
CREATE TABLE orders (
    id          INT PRIMARY KEY,
    created_at  TIMESTAMP  -- ← max 2038-01-19, stored as 32-bit int
);

-- ✅ FIXED: Use DATETIME or BIGINT for timestamps
CREATE TABLE orders_v2 (
    id          BIGINT PRIMARY KEY,
    -- DATETIME(3): microsecond precision, range 1000-9999 AD
    created_at  DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3),
    -- Or store epoch as BIGINT for portability
    epoch_ms    BIGINT NOT NULL   -- milliseconds since epoch, 64-bit
);

-- Migration: Convert existing TIMESTAMP → DATETIME
ALTER TABLE orders
    MODIFY COLUMN created_at DATETIME(3);

-- Check for timestamps that are already 2038-unsafe
SELECT id, created_at
FROM   orders
WHERE  created_at > '2038-01-19 03:14:07';  -- these are already broken

-- PostgreSQL: use TIMESTAMPTZ (internally 8-byte microseconds since 2000)
CREATE TABLE events (
    id         BIGSERIAL PRIMARY KEY,
    occurred   TIMESTAMPTZ NOT NULL DEFAULT now()  -- ✅ 8-byte, safe
);

# glibc 2.34+ on 32-bit Linux supports 64-bit time_t
# via _TIME_BITS=64 and _FILE_OFFSET_BITS=64

# ── Makefile ──────────────────────────────────────────────────
CFLAGS += -D_TIME_BITS=64           # Force 64-bit time_t on 32-bit glibc
CFLAGS += -D_FILE_OFFSET_BITS=64    # 64-bit off_t for large file support
CFLAGS += -Wall -Wextra
CFLAGS += -Werror=overflow          # Treat integer overflow as error

# Check at build time what size time_t is:
check-time-size:
    @echo "sizeof(time_t) = $(shell echo 'int main(){printf("%zu",sizeof(time_t));}' \
        | $(CC) -x c - $(CFLAGS) -o /tmp/sztest 2>/dev/null && /tmp/sztest)"

# ── CMake ─────────────────────────────────────────────────────
if(UNIX AND NOT APPLE)
    target_compile_definitions(myapp PRIVATE
        _TIME_BITS=64
        _FILE_OFFSET_BITS=64
    )
endif()

# ── Verify at runtime ─────────────────────────────────────────
#!/bin/bash
python3 -c "import struct, time; \
    t = int(time.time()); \
    b = struct.pack('i', t); \
    print(f'32-bit safe: {t < 2**31 - 1}') \
    if True else print('OVERFLOW RISK')"