// ownership.rs — 所有权随作用域释放；rustc --edition 2021 ownership.rs
use std::fs::File;
use std::io::{self, Read};

fn read_all(path: &str) -> io::Result<Vec<u8>> {
    let mut f = File::open(path)?;      // 失败自动返回 Err
    let mut buf = Vec::new();
    f.read_to_end(&mut buf)?;
    Ok(buf)                              // f 在函数结束时自动 close
}

fn main() -> io::Result<()> {
    let data = read_all("/etc/hosts")?;
    println!("{} bytes", data.len());
    Ok(())
}

/* ownership.c — 同样的读取；每条错误路径都要自己 close
 * cc -std=c17 -D_GNU_SOURCE -Wall -Wextra -Werror ownership.c -o ownership
 */
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

static int read_all(const char *path, char **out, size_t *out_len)
{
    int fd = open(path, O_RDONLY);
    if (fd < 0)
        return -1;
    size_t cap = 4096, len = 0;
    char *buf = malloc(cap);
    if (!buf) { close(fd); errno = ENOMEM; return -1; }
    for (;;) {
        if (len == cap) {
            char *nb = realloc(buf, cap * 2);
            if (!nb) { free(buf); close(fd); errno = ENOMEM; return -1; }
            buf = nb; cap *= 2;
        }
        ssize_t n = read(fd, buf + len, cap - len);
        if (n < 0) {
            if (errno == EINTR) continue;
            free(buf); close(fd); return -1;
        }
        if (n == 0) break;
        len += (size_t)n;
    }
    close(fd);
    *out = buf; *out_len = len;
    return 0;
}

int main(void)
{
    char *buf = NULL; size_t len = 0;
    if (read_all("/etc/hosts", &buf, &len) < 0) {
        perror("read_all"); return 1;
    }
    printf("%zu bytes\n", len);
    free(buf);
    return 0;
}

// borrow.rs — 借用检查器拒绝悬垂引用；以下函数若去掉注释会编译失败
fn first_word(s: &str) -> &str {
    s.split_whitespace().next().unwrap_or("")
}

// fn dangling() -> &str {
//     let s = String::from("hello");
//     &s[..]                 // error: `s` does not live long enough
// }

struct Parser<'a> {
    input: &'a str,
    pos: usize,
}

impl<'a> Parser<'a> {
    fn new(input: &'a str) -> Self {
        Self { input, pos: 0 }
    }
    fn rest(&self) -> &'a str { &self.input[self.pos..] }
}

fn main() {
    let text = String::from("hello world");
    println!("{}", first_word(&text));
    let p = Parser::new(&text);
    println!("{}", p.rest());
}

// errors.rs — 自定义错误、?、errno 映射；rustc --edition 2021 errors.rs
use std::error::Error;
use std::fmt;
use std::fs::File;
use std::io::{self, Read};

#[derive(Debug)]
enum LoadError {
    Io(io::Error),
    Empty,
}

impl fmt::Display for LoadError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            LoadError::Io(e) => write!(f, "io: {e}"),
            LoadError::Empty => write!(f, "file is empty"),
        }
    }
}

impl Error for LoadError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            LoadError::Io(e) => Some(e),
            LoadError::Empty => None,
        }
    }
}

impl From<io::Error> for LoadError {
    fn from(e: io::Error) -> Self { LoadError::Io(e) }
}

fn load(path: &str) -> Result<Vec<u8>, LoadError> {
    let mut f = File::open(path)?;       // io::Error -> LoadError
    let mut buf = Vec::new();
    f.read_to_end(&mut buf)?;
    if buf.is_empty() { return Err(LoadError::Empty); }
    Ok(buf)
}

fn main() {
    match load("/etc/hosts") {
        Ok(b) => println!("{} bytes", b.len()),
        Err(e) => {
            eprintln!("load failed: {e}");
            if let Some(src) = e.source() { eprintln!("caused by: {src}"); }
            std::process::exit(1);
        }
    }
}

// errno.rs — 读 errno 的正确与错误姿势
use std::fs::File;
use std::io;

fn main() {
    match File::open("/definitely/not/here") {
        Ok(_) => unreachable!(),
        Err(e) => {
            // 正确：e 已经保存了失败瞬间的 errno
            println!("kind={:?} raw={:?}", e.kind(), e.raw_os_error());
            // 错误：先做别的事再读 last_os_error，可能已被覆盖
            let _ = std::env::var("PATH");
            println!("last_os_error={:?}", io::Error::last_os_error().raw_os_error());
        }
    }
}

# sys_write_x86_64.s — clang --target=x86_64-linux-gnu -c
    .text
    .globl sys_write
    .type sys_write, @function
sys_write:
    movq    $1, %rax          # SYS_write
    syscall                   # rdi=fd, rsi=buf, rdx=len
    ret                       # 返回 rax；失败为 -errno
    .size sys_write, . - sys_write

// sys_write_arm64.s — clang --target=aarch64-linux-gnu -c
    .text
    .globl sys_write
    .type sys_write, %function
sys_write:
    mov     x8, #64           // SYS_write
    svc     #0                // x0=fd, x1=buf, x2=len
    ret                       // 返回 x0
    .size sys_write, . - sys_write

# sys_write_riscv64.s — clang --target=riscv64-linux-gnu -c
    .text
    .globl sys_write
    .type sys_write, @function
sys_write:
    li      a7, 64            # SYS_write（asm-generic）
    ecall                     # a0=fd, a1=buf, a2=len
    ret                       # 返回 a0
    .size sys_write, . - sys_write

// safe_fd.rs — 用 RAII 封装 raw fd；rustc --edition 2021 safe_fd.rs
use std::io;
use std::os::fd::{FromRawFd, RawFd};
use std::os::unix::io::AsRawFd;
use std::fs::File;

/// 拥有所有权的 fd；Drop 时关闭。
pub struct OwnedFd(File);

impl OwnedFd {
    /// # Safety
    /// `fd` 必须是有效的、由调用者转移所有权的文件描述符。
    pub unsafe fn from_raw(fd: RawFd) -> Self {
        // SAFETY: 调用者保证 fd 有效且所有权转移；File 会负责 close。
        OwnedFd(unsafe { File::from_raw_fd(fd) })
    }

    pub fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
        use std::io::Write;
        self.0.write_all(buf)
    }

    pub fn raw(&self) -> RawFd { self.0.as_raw_fd() }
}

fn main() -> io::Result<()> {
    let f = std::fs::OpenOptions::new().write(true).open("/dev/null")?;
    let fd = f.as_raw_fd();
    std::mem::forget(f);                       // 避免双重关闭
    let mut owned = unsafe { OwnedFd::from_raw(fd) };
    owned.write_all(b"x")?;
    Ok(())
}

/* copy.c — 处理 EINTR、短读、短写；cc -std=c17 -D_GNU_SOURCE -Wall -Wextra -Werror copy.c -o copy */
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>

static int write_all(int fd, const char *p, size_t n)
{
    while (n > 0) {
        ssize_t w = write(fd, p, n);
        if (w < 0) {
            if (errno == EINTR) continue;
            return -1;
        }
        if (w == 0) { errno = EIO; return -1; }   /* 不该发生，但不能死循环 */
        p += (size_t)w;
        n -= (size_t)w;
    }
    return 0;
}

static int copy_file(const char *src, const char *dst)
{
    int in = open(src, O_RDONLY | O_CLOEXEC);
    if (in < 0) return -1;
    int out = open(dst, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0644);
    if (out < 0) { int e = errno; close(in); errno = e; return -1; }

    char buf[65536];
    int rc = 0;
    for (;;) {
        ssize_t n = read(in, buf, sizeof buf);
        if (n < 0) {
            if (errno == EINTR) continue;
            rc = -1; break;
        }
        if (n == 0) break;
        if (write_all(out, buf, (size_t)n) < 0) { rc = -1; break; }
    }
    int saved = errno;
    if (close(in) < 0 && rc == 0) { rc = -1; saved = errno; }
    if (close(out) < 0 && rc == 0) { rc = -1; saved = errno; }
    errno = saved;
    return rc;
}

int main(int argc, char **argv)
{
    if (argc != 3) {
        fprintf(stderr, "usage: %s SRC DST\n", argv[0]);
        return 2;
    }
    if (copy_file(argv[1], argv[2]) < 0) {
        perror("copy");
        return 1;
    }
    return 0;
}

// copy.rs — 标准库版本；rustc --edition 2021 copy.rs -o copy
use std::fs::{self, File};
use std::io::{self, Write};
use std::os::unix::fs::PermissionsExt;

fn copy_file(src: &str, dst: &str) -> io::Result<u64> {
    let meta = fs::metadata(src)?;
    println!("src mode = {:o}", meta.permissions().mode());

    let mut inp = File::open(src)?;
    let mut out = File::create(dst)?;
    let n = io::copy(&mut inp, &mut out)?;   // 内部处理短读/短写/EINTR
    out.flush()?;                            // 显式 flush，错误不会被 Drop 吞掉
    Ok(n)
}

fn main() -> io::Result<()> {
    let args: Vec<String> = std::env::args().collect();
    if args.len() != 3 {
        eprintln!("usage: {} SRC DST", args[0]);
        std::process::exit(2);
    }
    let n = copy_file(&args[1], &args[2])?;
    println!("copied {n} bytes");
    Ok(())
}

/* threads.c — 4 个线程各加 100000 次；cc ... -pthread threads.c -o threads */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

struct counter {
    pthread_mutex_t mu;
    long value;
};

static void *worker(void *arg)
{
    struct counter *c = arg;
    for (int i = 0; i < 100000; i++) {
        if (pthread_mutex_lock(&c->mu) != 0) abort();
        c->value++;
        if (pthread_mutex_unlock(&c->mu) != 0) abort();
    }
    return NULL;
}

int main(void)
{
    struct counter c;
    pthread_t th[4];
    if (pthread_mutex_init(&c.mu, NULL) != 0) return 1;
    c.value = 0;
    for (int i = 0; i < 4; i++)
        if (pthread_create(&th[i], NULL, worker, &c) != 0) return 1;
    for (int i = 0; i < 4; i++)
        if (pthread_join(th[i], NULL) != 0) return 1;
    printf("value=%ld\n", c.value);
    pthread_mutex_destroy(&c.mu);
    return c.value == 400000 ? 0 : 1;
}

// threads.rs — scoped threads + Mutex；rustc --edition 2021 threads.rs -o threads
use std::sync::Mutex;
use std::thread;

fn main() {
    let counter = Mutex::new(0u64);
    thread::scope(|s| {
        for _ in 0..4 {
            s.spawn(|| {
                for _ in 0..100_000 {
                    let mut v = counter.lock().unwrap();
                    *v += 1;
                }
            });
        }
    });
    let v = counter.into_inner().unwrap();
    println!("value={v}");
    assert_eq!(v, 400_000);
}

/* echo.c — 单线程 TCP echo；cc -std=c17 -D_GNU_SOURCE -Wall -Wextra -Werror echo.c -o echo */
#include <arpa/inet.h>
#include <errno.h>
#include <netinet/in.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

static int write_all(int fd, const char *p, size_t n)
{
    while (n > 0) {
        ssize_t w = write(fd, p, n);
        if (w < 0) { if (errno == EINTR) continue; return -1; }
        if (w == 0) { errno = EIO; return -1; }
        p += (size_t)w; n -= (size_t)w;
    }
    return 0;
}

int main(int argc, char **argv)
{
    int port = argc > 1 ? atoi(argv[1]) : 7878;
    signal(SIGPIPE, SIG_IGN);              /* 对端关闭后 write 返回 EPIPE，而不是杀死进程 */

    int s = socket(AF_INET, SOCK_STREAM, 0);
    if (s < 0) { perror("socket"); return 1; }
    int one = 1;
    setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &one, sizeof one);

    struct sockaddr_in addr;
    memset(&addr, 0, sizeof addr);
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    addr.sin_port = htons((unsigned short)port);
    if (bind(s, (struct sockaddr *)&addr, sizeof addr) < 0) { perror("bind"); return 1; }
    if (listen(s, 16) < 0) { perror("listen"); return 1; }
    fprintf(stderr, "listening on 127.0.0.1:%d\n", port);

    for (;;) {
        int c = accept(s, NULL, NULL);
        if (c < 0) { if (errno == EINTR) continue; perror("accept"); return 1; }
        char buf[4096];
        for (;;) {
            ssize_t n = read(c, buf, sizeof buf);
            if (n < 0) { if (errno == EINTR) continue; perror("read"); break; }
            if (n == 0) break;                 /* 对端关闭 */
            if (write_all(c, buf, (size_t)n) < 0) { perror("write"); break; }
        }
        close(c);
    }
}

// echo.rs — 单线程 TCP echo；rustc --edition 2021 echo.rs -o echo-rs
use std::io::{self, Read, Write};
use std::net::TcpListener;

fn main() -> io::Result<()> {
    let listener = TcpListener::bind(("127.0.0.1", 7878))?;
    eprintln!("listening on 127.0.0.1:7878");
    for conn in listener.incoming() {
        let mut stream = conn?;               // 连接错误：返回 Err，退出循环
        let mut buf = [0u8; 4096];
        loop {
            match stream.read(&mut buf) {
                Ok(0) => break,                // EOF
                Ok(n) => stream.write_all(&buf[..n])?,
                Err(e) if e.kind() == io::ErrorKind::Interrupted => continue,
                Err(e) => return Err(e),
            }
        }
    }
    Ok(())
}

// unix_ext.rs — 用 std::os::unix 读 inode、权限、fd；rustc --edition 2021 unix_ext.rs
use std::fs::File;
use std::os::unix::fs::{MetadataExt, PermissionsExt};
use std::os::unix::io::AsRawFd;

fn main() -> std::io::Result<()> {
    let f = File::open("/etc/hosts")?;
    let m = f.metadata()?;
    println!("fd={} ino={} mode={:o} uid={} gid={} size={}",
             f.as_raw_fd(), m.ino(), m.permissions().mode(),
             m.uid(), m.gid(), m.size());
    Ok(())
}

/* stat_demo.c — 与上面等价的 C 版本
 * cc -std=c17 -D_GNU_SOURCE -Wall -Wextra -Werror stat_demo.c -o stat_demo
 */
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main(void)
{
    int fd = open("/etc/hosts", O_RDONLY | O_CLOEXEC);
    if (fd < 0) { perror("open"); return 1; }
    struct stat st;
    if (fstat(fd, &st) < 0) { perror("fstat"); close(fd); return 1; }
    printf("fd=%d ino=%llu mode=%o uid=%u gid=%u size=%lld\n",
           fd, (unsigned long long)st.st_ino, st.st_mode & 07777,
           st.st_uid, st.st_gid, (long long)st.st_size);
    close(fd);
    return 0;
}

// libc_pid.rs — 直接声明 libc 函数，不依赖 libc crate
// rustc --edition 2021 libc_pid.rs -o libc_pid
use std::ffi::CStr;
use std::os::raw::{c_char, c_int};

extern "C" {
    fn getpid() -> c_int;
    fn strerror(errnum: c_int) -> *const c_char;
}

fn main() {
    let pid = unsafe { getpid() };
    let msg = unsafe { CStr::from_ptr(strerror(2)) };  // ENOENT = 2
    println!("pid={pid} errno2={}", msg.to_string_lossy());
}