/* musl 的 strlen 实现 - 简洁清晰 */
/* 来自 src/string/strlen.c */

#include <string.h>
#include <stdint.h>
#include <limits.h>

#define ALIGN (sizeof(size_t))
#define ONES ((size_t)-1/UCHAR_MAX)
#define HIGHS (ONES * (UCHAR_MAX/2+1))
#define HASZERO(x) ((x)-ONES & ~(x) & HIGHS)

size_t strlen(const char *s)
{
    const char *a = s;
    const size_t *w;
#if !defined(__x86_64__) && !defined(__i386__)
    /* 非对齐读取在某些架构上是 UB */
    for (; (uintptr_t)s % ALIGN; s++)
        if (!*s) return s-a;
#endif
    for (w = (const void *)s; !HASZERO(*w); w++);
    for (s = (const void *)w; *s; s++);
    return s-a;
}
/* 仅 20 余行，利用 word-at-a-time 技巧高效处理 */

/* 一个功能完整的静态链接网络程序 */
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>
#include <errno.h>

int main(int argc, char *argv[]) {
    if (argc < 2) {
        fprintf(stderr, "Usage: %s <hostname>\n", argv[0]);
        return 1;
    }

    /* DNS 解析 - glibc 静态链接时可能失败，musl 正常工作 */
    struct addrinfo hints = {0}, *res;
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_STREAM;

    int err = getaddrinfo(argv[1], "80", &hints, &res);
    if (err) {
        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(err));
        return 1;
    }

    char ip[INET_ADDRSTRLEN];
    struct sockaddr_in *addr = (struct sockaddr_in *)res->ai_addr;
    inet_ntop(AF_INET, &addr->sin_addr, ip, sizeof(ip));
    printf("Resolved %s -> %s\n", argv[1], ip);

    freeaddrinfo(res);
    return 0;
}

/*
 * 编译：
 * $ musl-gcc -static -O2 -o dnsresolve dnsresolve.c
 * $ ldd dnsresolve
 *   Not a dynamic executable
 * $ file dnsresolve
 *   dnsresolve: ELF 64-bit LSB executable, statically linked
 *
 * $ ls -lh dnsresolve
 *   -rwxr-xr-x 1 user user 286K ... dnsresolve
 */

/* musl 的 malloc 实现相对简单，减少了复杂攻击面 */

/* glibc 的 ptmalloc 实现复杂，历史上有多个 CVE */
/* 例如：CVE-2015-0235 (Ghost) - glibc gethostbyname 缓冲区溢出 */
/* 例如：CVE-2015-7547 - glibc DNS 解析器栈缓冲区溢出 */

/* musl 的 malloc 简单实现示例（简化版）：
 * - 使用 mmap 直接向内核申请大块内存
 * - 小对象使用简单的 slab 分配器
 * - 没有复杂的 bin 管理和合并策略
 * - 碎片更少，但大块分配的并发性能不如 glibc
 */

/* FORTIFY_SOURCE 编译时缓冲区溢出检测 */
#include <stdio.h>
#include <string.h>

int main() {
    char buf[10];
    /* 这在 glibc 和 musl 上都会产生编译时或运行时警告 */
    sprintf(buf, "This string is way too long for the buffer!");
    return 0;
}

/*
 * 编译：
 * $ musl-gcc -D_FORTIFY_SOURCE=2 -O2 -o fortify fortify.c
 * 运行：
 * *** buffer overflow detected ***: terminated
 *
 * musl 的 FORTIFY_SOURCE 实现更简洁，
 * 但检查覆盖面不如 glibc 全面。
 */

/* Y2038 问题说明 */
#include <time.h>
#include <stdio.h>
#include <limits.h>

int main() {
    printf("sizeof(time_t) = %zu bits\n", sizeof(time_t) * 8);

    /* glibc 在 32 位平台上（传统）：time_t = 32 位
     * 最大表示 2038-01-19 03:14:07 UTC
     *
     * glibc 在 64 位平台上：time_t = 64 位，无此问题
     * glibc 在 32 位平台上（新版本）：可通过宏切换到 64 位 time_t
     *
     * musl 从 1.2.0 起：time_t 在所有平台都是 64 位
     * 这保证了 musl 在 32 位嵌入式设备上也能正确处理 2038 年后的时间
     */

    time_t max_time = (time_t)((1ULL << (sizeof(time_t)*8-1)) - 1);
    printf("Max representable year: ~%ld\n", 1970 + max_time / (365.25 * 86400));
    return 0;
}

/* musl 的线程栈默认 128KB，但可以精确控制 */
#include <pthread.h>
#include <stdio.h>
#include <string.h>

/* musl 使用 guard page 机制防止栈溢出破坏其他内存 */
/* 与 glibc 不同，musl 的线程栈不会自动增长 */

void *thread_func(void *arg) {
    /* 在 musl 中，如果递归太深，会触发 SIGSEGV */
    /* 而 glibc 可能通过自动增长栈来处理（最终也会 OOM） */
    char buf[4096];
    memset(buf, 0, sizeof(buf));
    printf("Thread stack usage: %zu\n", sizeof(buf));
    return NULL;
}

int main() {
    pthread_t tid;
    pthread_attr_t attr;

    pthread_attr_init(&attr);
    pthread_attr_setstacksize(&attr, 512 * 1024);  /* 512KB */

    pthread_create(&tid, &attr, thread_func, NULL);
    pthread_join(tid, NULL);

    pthread_attr_destroy(&attr);
    return 0;
}

/* TLS 实现差异 */
#include <pthread.h>
#include <stdio.h>

/* 两者都支持 __thread 关键字 */
__thread int tls_var = 0;

void *thread_func(void *arg) {
    tls_var = (int)(long)arg;
    printf("Thread %ld: tls_var = %d\n", (long)arg, tls_var);
    return NULL;
}

int main() {
    pthread_t tids[3];
    for (int i = 0; i < 3; i++) {
        pthread_create(&tids[i], NULL, thread_func, (void *)(long)(i+1));
    }
    for (int i = 0; i < 3; i++) {
        pthread_join(tids[i], NULL);
    }
    return 0;
}

/*
 * glibc TLS 实现：
 * - 使用 ELF TLS ABI，通过 FS/GS 段寄存器访问
 * - 支持 __thread 和 C11 _Thread_local
 * - 动态 TLS 模块通过 __tls_get_addr() 访问
 *
 * musl TLS 实现：
 * - 同样使用 ELF TLS ABI
 * - 实现更简洁，但功能完整
 * - 静态 TLS 有固定槽位限制（通常 128+ 个）
 */

/* musl malloc 特点：
 * 1. 大块内存直接使用 mmap()
 * 2. 小块内存使用简单的 slab 分配器
 * 3. 没有 per-thread arena（并发性能不如 glibc）
 * 4. 碎片更少
 * 5. 代码量小，攻击面小
 */

/* 测试 malloc 并发性能 */
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <time.h>

#define NUM_THREADS 8
#define ALLOCS_PER_THREAD 100000

void *alloc_thread(void *arg) {
    void *ptrs[100];
    for (int i = 0; i < ALLOCS_PER_THREAD; i++) {
        int idx = i % 100;
        size_t size = 16 + (i % 4096);
        ptrs[idx] = malloc(size);
        if (ptrs[idx]) {
            memset(ptrs[idx], i & 0xff, size);
        }
        if (i >= 100) {
            free(ptrs[(i - 100) % 100]);
        }
    }
    /* 清理剩余 */
    for (int i = 0; i < 100; i++) {
        free(ptrs[i]);
    }
    return NULL;
}

int main() {
    pthread_t tids[NUM_THREADS];
    struct timespec start, end;

    clock_gettime(CLOCK_MONOTONIC, &start);
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_create(&tids[i], NULL, alloc_thread, NULL);
    }
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(tids[i], NULL);
    }
    clock_gettime(CLOCK_MONOTONIC, &end);

    double elapsed = (end.tv_sec - start.tv_sec) +
                     (end.tv_nsec - start.tv_nsec) / 1e9;
    printf("8 threads x 100K allocs: %.3f sec\n", elapsed);
    return 0;
}

/*
 * glibc ptmalloc: 使用 per-thread arena，多线程并发分配快
 * musl malloc:   使用全局锁，多线程并发可能成为瓶颈
 *
 * 建议：如果程序大量并发 malloc/free，考虑使用 jemalloc 或 mimalloc
 */

/* 两者都支持 POSIX regex */
#include <regex.h>
#include <stdio.h>

int main() {
    regex_t regex;
    int ret;

    ret = regcomp(&regex, "^https?://[^/]+/.*$", REG_EXTENDED);
    if (ret) {
        char errbuf[256];
        regerror(ret, regex, errbuf, sizeof(errbuf));
        printf("Error: %s\n", errbuf);
        return 1;
    }

    const char *test_urls[] = {
        "https://example.com/path",
        "http://test.org",
        "ftp://invalid.com",
        NULL
    };

    for (int i = 0; test_urls[i]; i++) {
        ret = regexec(&regex, test_urls[i], 0, NULL, 0);
        printf("%-30s %s\n", test_urls[i], ret == 0 ? "MATCH" : "NO MATCH");
    }

    regfree(&regex);
    return 0;
}

/*
 * musl 的 regex 实现：
 * - 支持 BRE 和 ERE
 * - 支持基本的 POSIX 字符类
 * - 不支持 GNU 扩展正则语法
 * - 性能与 glibc 相当
 */

# 获取 musl 源码
$ git clone git://git.musl-libc.org/musl
$ cd musl

# 统计代码行数
$ find src -name "*.c" -o -name "*.h" | xargs wc -l | tail -1
# ~100,000 lines

# 对比 glibc
$ git clone https://sourceware.org/git/glibc.git
$ cd glibc
$ find -name "*.c" -o -name "*.h" | xargs wc -l | tail -1
# ~1,000,000 lines

# 审计一个完整 musl 实现的估算时间
# 假设每天审计 500 行，需要约 200 个工作日
# glibc 则需要约 2000 个工作日