/* C11 特性示例：两者都支持 _Generic */
#include <stdio.h>

#define print_type(x) _Generic((x),    \
    int:     "int",                     \
    float:   "float",                   \
    double:  "double",                  \
    char*:   "string",                  \
    default: "unknown"                  \
)

int main() {
    int i = 42;
    float f = 3.14f;
    double d = 2.718;
    char *s = "hello";

    printf("i is %s\n", print_type(i));  // int
    printf("f is %s\n", print_type(f));  // float
    printf("d is %s\n", print_type(d));  // double
    printf("s is %s\n", print_type(s));  // string
    return 0;
}

/* 编译：gcc -std=c11 -o generic generic.c
 * 在 glibc 和 musl 上均能正常编译运行 */

/* glibc 独有的 error() 函数示例 */
#define _GNU_SOURCE
#include <error.h>      /* glibc 专有头文件 */
#include <stdio.h>
#include <errno.h>

int main() {
    FILE *fp = fopen("/nonexistent", "r");
    if (!fp) {
        /* 在 glibc 上正常工作，在 musl 上编译失败：
         * fatal error: error.h: No such file or directory */
        error(1, errno, "failed to open file");
    }
    return 0;
}

# 测量简单 C 程序的内存占用
$ cat <<'EOF' > /tmp/memtest.c
#include <stdio.h>
#include <unistd.h>

int main() {
    char buf[64];
    snprintf(buf, sizeof(buf), "/proc/%d/status", getpid());
    FILE *fp = fopen(buf, "r");
    char line[256];
    while (fgets(line, sizeof(line), fp)) {
        printf("%s", line);
    }
    fclose(fp);
    return 0;
}
EOF

# 在 glibc 环境编译运行
$ gcc -o /tmp/memtest_glibc /tmp/memtest.c && /tmp/memtest_glibc | grep VmRSS

# 在 musl 环境编译运行
$ musl-gcc -o /tmp/memtest_musl /tmp/memtest.c && /tmp/memtest_musl | grep VmRSS

/* 设置线程栈大小示例 */
#include <pthread.h>
#include <stdio.h>

void *thread_func(void *arg) {
    printf("Thread running\n");
    return NULL;
}

int main() {
    pthread_t tid;
    pthread_attr_t attr;

    pthread_attr_init(&attr);
    /* musl 默认 128KB，glibc 默认 8MB
     * 如果程序需要更大的栈，显式设置 */
    pthread_attr_setstacksize(&attr, 2 * 1024 * 1024);  /* 2MB */

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

    pthread_attr_destroy(&attr);
    return 0;
}

/* 编译：gcc -pthread -o stacksize stacksize.c */

# 简单的 memcpy 性能测试
$ cat <<'EOF' > /tmp/bench_memcpy.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>

int main() {
    const size_t size = 64 * 1024 * 1024;  /* 64 MB */
    const int iterations = 100;
    char *src = malloc(size);
    char *dst = malloc(size);
    memset(src, 'A', size);

    struct timespec start, end;
    clock_gettime(CLOCK_MONOTONIC, &start);

    for (int i = 0; i < iterations; i++) {
        memcpy(dst, src, size);
    }

    clock_gettime(CLOCK_MONOTONIC, &end);
    double elapsed = (end.tv_sec - start.tv_sec) +
                     (end.tv_nsec - start.tv_nsec) / 1e9;

    printf("memcpy 64MB x %d: %.3f sec (%.1f GB/s)\n",
           iterations, elapsed,
           (double)size * iterations / elapsed / 1e9);

    free(src);
    free(dst);
    return 0;
}
EOF

# 分别在 glibc 和 musl 环境下编译运行
$ gcc -O2 -o /tmp/bench_glibc /tmp/bench_memcpy.c && /tmp/bench_glibc
$ musl-gcc -O2 -o /tmp/bench_musl /tmp/bench_memcpy.c && /tmp/bench_musl

# 动态链接编译
$ gcc -o hello_dynamic hello.c          # glibc 动态链接
$ musl-gcc -o hello_dynamic hello.c     # musl 动态链接

# 查看动态依赖
$ ldd hello_dynamic
# glibc:
#   linux-vdso.so.1 (0x00007ffd...)
#   libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f...)
# musl (Alpine):
#   /lib/ld-musl-x86_64.so.1 (0x7f...)

# glibc 静态链接（不推荐）
$ gcc -static -o hello_static_glibc hello.c
$ ldd hello_static_glibc
#   not a dynamic executable

# ⚠️ glibc 静态链接的问题：
# 1. NSS 功能失效（DNS 解析、用户查询等）
# 2. 二进制体积大（约 2-5 MB）
# 3. 不支持 dlopen()
# 4. locale 支持不完整

# musl 静态链接（推荐）
$ musl-gcc -static -o hello_static_musl hello.c
$ ldd hello_static_musl
#   Not a dynamic executable

# ✅ musl 静态链接的优势：
# 1. 二进制体积小（约 100-500 KB）
# 2. DNS 解析正常工作
# 3. 无外部依赖，可部署到任意 Linux
# 4. 适合容器和嵌入式场景

# 一个简单的 HTTP 客户端程序
$ cat <<'EOF' > /tmp/httpget.c
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    if (argc < 2) {
        fprintf(stderr, "Usage: %s <hostname>\n", argv[0]);
        return 1;
    }
    struct hostent *server = gethostbyname(argv[1]);
    if (!server) {
        fprintf(stderr, "DNS lookup failed\n");
        return 1;
    }
    printf("Resolved: %s\n", argv[1]);
    return 0;
}
EOF

$ gcc -static -O2 -o /tmp/httpget_glibc /tmp/httpget.c
$ musl-gcc -static -O2 -o /tmp/httpget_musl /tmp/httpget.c

$ ls -lh /tmp/httpget_glibc /tmp/httpget_musl
# -rwxr-xr-x 1 user user 2.1M ... /tmp/httpget_glibc
# -rwxr-xr-x 1 user user 286K ... /tmp/httpget_musl

# glibc 编译的程序无法在 musl 系统上运行
$ ./program_compiled_with_glibc
# Error: /lib/ld-linux-x86-64.so.2: No such file or directory
# 或：/lib/ld-musl-x86_64.so.1: Error loading shared library

# 解决方案 1：静态链接（推荐）
$ musl-gcc -static -o program program.c

# 解决方案 2：使用兼容层
$ apk add gcompat    # Alpine 上安装 glibc 兼容层
$ ./program_compiled_with_glibc

/* 检测 libc 类型的可移植方法 */
#include <stdio.h>

int main() {
#if defined(__GLIBC__)
    printf("glibc %d.%d\n", __GLIBC__, __GLIBC_MINOR__);
#elif defined(__musl__)
    printf("musl\n");
#elif defined(__BIONIC__)
    printf("Android Bionic\n");
#else
    printf("Unknown libc\n");
#endif
    return 0;
}

# glibc 通过 NSS 决定 DNS 解析方式
$ cat /etc/nsswitch.conf
# hosts: files dns myhostname

# glibc 的 DNS 解析链：
# 1. 查 /etc/hosts
# 2. 根据 nsswitch.conf 配置决定
# 3. 查 /etc/resolv.conf 获取 DNS 服务器
# 4. 可选：mDNS (Avahi)、LDAP、NIS 等

# musl 只看 /etc/resolv.conf 和 /etc/hosts
# 不支持 nsswitch.conf
$ cat /etc/resolv.conf
nameserver 8.8.8.8

# musl 的 DNS 解析链：
# 1. 查 /etc/hosts
# 2. 根据 /etc/resolv.conf 配置的 nameserver 查询
# 3. 支持 search domain
# 4. 不支持 NIS、LDAP、mDNS 等

/* DNS 解析差异示例 */
#include <stdio.h>
#include <netdb.h>
#include <arpa/inet.h>

int main() {
    struct hostent *h = gethostbyname("www.example.com");
    if (h) {
        char ip[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, h->h_addr_list[0], ip, sizeof(ip));
        printf("IP: %s\n", ip);
    } else {
        printf("Lookup failed: %s\n", hstrerror(h_errno));
    }
    return 0;
}

/*
 * glibc：通过 nsswitch.conf 可以走 NIS、LDAP、mDNS 等
 * musl：只通过 /etc/resolv.conf 的 nameserver 查询
 *
 * 在 Docker 容器中，两者行为通常一致，
 * 因为容器的 /etc/resolv.conf 由 Docker 自动生成。
 */

# glibc 的 iconv 模块
$ ls /usr/lib/x86_64-linux-gnu/gconv/ | head -10
# 有数百个编码转换模块

# musl 的 iconv 是编译时内置的，不支持额外加载模块