文件IO

$ulimit -n
1024

#include <fcntl.h> // file control header file
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
// 成功返回最小的未用文件描述符数值，失败返回-1。

$ cat open_ret_test.c 
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
int main()
{
    //关闭标准输流
    close(STDIN_FILENO);
    //打开任意文件
    int fd = open("./fd_test", O_RDWR);
    if (fd != -1)
    {
        printf("fd=%d\n", fd);
    }
    else
    {
        perror("oepn failed");
    }
}

$ touch fd_test
$ ./open_ret_test 
fd=0

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main()
{
    //输出当前的有效用户名
    //保证当前用户为root
    printf("EUID=%d, UID=%d\n", geteuid(), getuid());
    int fd = open("/etc/shadow", O_RDONLY);
    if (fd != -1)
    {
        printf("/etc/shadow open successfully\n");
    }
    else
    {
        perror("open failed");
        return 0;
    }

    pid_t pid = fork();
    if (pid == 0)
    {
        //进入到子进程中
        //设置用户ID和有效用户ID
        seteuid(1000);
        setegid(1000);
        char buf[32] = {0};
        printf("EUID=%d, UID=%d\n", geteuid(), getuid());
        //从父进程中泄漏的文件描述符，可以读取文件
        while (read(fd, buf, sizeof(buf)) > 0)
        {
            printf("%s", buf);
        }
        close(fd);

        //普通用户无权限打开
        fd = open("/etc/shadow", O_RDONLY);
        if (fd != -1)
        {
            printf("/etc/shadow open successfully\n");
            close(fd);
        }
        else
        {
            perror("open failed");
        }
    }

    sleep(3);
    close(fd);
    return 0;
}

#include <fcntl.h>

int creat(const char* path, mode_t mode);
// 成功返回文件描述符，失败返回-1。

#include <unistd.h>

int close(int fd);
// 成功返回0，失败返回-1。

#include <unistd.h>

off_t lseek(int fd, off_t offset, int whence);
成功返回文件偏移量，失败返回-1。

#include <stdio.h>
#include <unistd.h>

int main()
{
    if (lseek(STDIN_FILENO, 0, SEEK_CUR) == -1)
    {
        perror("cannot seek");
    }
    else
    {
        printf("seek ok\n");
    }
    return 0;
}

$ ./lseek_test < /etc/passwd
seek ok
$ cat /etc/passwd | ./lseek_test 
cannot seek: Illegal seek

#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

int main()
{
    char buf1[] = "abcdefghij";
    char buf2[] = "ABCDEFGHIJ";

    int fd = open("file.hole", O_RDWR | O_CREAT | O_TRUNC,
        S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
    if (fd < 0)
    {
        perror("create file failed");
    }
    //写入文件
    if (write(fd, buf1, strlen(buf1)) != 10)
    {
        perror("write failed");
        return 0;
    }
    // offset now = 10;

    // lseek 制造空洞
    if (lseek(fd, 16384, SEEK_SET) == -1)
    {
        perror("lseek failed");
    }
    // offset now=16384

    if (write(fd, buf2, strlen(buf2)) != strlen(buf2))
    {
        perror("write failed");
        return 0;
    }
    // offset now=16394

    //创建非空洞文件
    fd = open("file.nohole", O_RDWR | O_CREAT | O_TRUNC,
        S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
    if (fd < 0)
    {
        perror("create file failed");
    }
    int i = 0;
    while (i < 1639)
    {
        if (write(fd, buf1, strlen(buf1)) != strlen(buf1))
        {
            perror("write failed");
        }
        i++;
    }

    write(fd, "abcd", strlen("abcd"));
    close(fd);
    return 0;
}

$ ls -ls file.*
 8 -rw-rw---- 1 blduan blduan 16394 Feb 27 01:20 file.hole
20 -rw-rw---- 1 blduan blduan 16394 Feb 27 01:20 file.nohole

#include <unistd.h>
ssize_t read(int fd, void *buf, size_t nbytes);
// 返回值：读到的字节数，若已到文件尾，返回0；若出错，返回-1。

#include <unistd.h>
ssize_t write(int fd, const void* buf, size_t nbytes);
// 返回值：成功返回写入的字节数，失败返回-1。

// /usr/include/sched.h
struct task_struct{
    ...
    /* Open file information */
    struct files_struct;
    ...
}

// /usr/include/fdtable.h
/*
 * Open file table structure
 */
struct files_struct {
    // 读相关字段
    atomic_t count;
    bool resize_in_progress;
    wait_queue_head_t resize_wait;

    // 打开的文件管理结构
    struct fdtable __rcu *fdt;
    struct fdtable fdtab; //优化策略，默认情况下fdt指向fdtab，只有真正需要时才会动态分配

    // 写相关字段
    unsigned int next_fd;
    unsigned long close_on_exec_init[1];
    unsigned long open_fds_init[1];
    unsigned long full_fds_bits_init[1];
    struct file * fd_array[NR_OPEN_DEFAULT];
};

struct file {
    // ...
    struct path                     f_path;
    struct inode                    *f_inode;
    const struct file_operations    *f_op;

    atomic_long_t                    f_count;
    unsigned int                     f_flags;
    fmode_t                          f_mode;
    struct mutex                     f_pos_lock;
    loff_t                           f_pos;
    struct fown_struct               f_owner;
    // ...
}

#include <unistd.h>
int dup(int fd);
int dup2(int fd, int fd2);
// 成功返回新的文件描述符，失败返回-1。

#include <fcntl.h>
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>

int main()
{
    // 0,1,2分别是标准输，标准输出，标准错误的文件描述符，并且进程默认是打开。
    // open函数会返回最小未用的文件描述符，如果打开正常，则fd1==3;
    int fd1 =
        open("./test", O_CREAT | O_RDWR, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
    if (fd1 != -1)
    {
        printf("%d\n", fd1);
    }
    else
    {
        perror("open failed");
        return 0;
    }
    int fd2 = open("./test1", O_CREAT | O_RDWR,
        S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);  // 如果正常打开，则fd2==4
    if (fd2 != -1)
    {
        printf("%d\n", fd2);
    }
    else
    {
        perror("open failed");
        return 0;
    }

    //现在关闭fd1，则文件描述符3为最小可用的。
    close(fd1);

    int fd3 = dup(STDIN_FILENO);
    if (fd3 != -1)
    {
        printf("%d\n", fd3);  //正常情况下 fd==3
    }
    else
    {
        perror("open failed");
        return 0;
    }

    close(fd2);
    close(fd3);
    return 0;
}

$ ./dup_return_min_fd 
3
4
3

#include <unistd.h>

int fsync(int fd);
int fdatasync(int fd);
// 成功返回0，失败返回-1

void sync(void);

#include <fcntl.h>
int fcntl(int fd, int cmd, ...);
// 成功返回值依赖于cmd，失败返回值为-1。

#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>

int main()
{
    // fcntl会返回大于或等于第3个参数的新文件描述符
    // 会清除新文件描述符的FD_CLOEXEC标志
    int fd = fcntl(STDIN_FILENO, F_DUPFD, 5);  //正常情况下fd的值为5
    if (fd == -1)
    {
        perror("fcntl failed");
    }
    else
    {
        printf("%d\n", fd);
    }
    int fdFlags = fcntl(fd, F_GETFD);
    printf("%d\n", fdFlags);  // FD_CLOEXEC标志被清除，值为0
    close(fd);
    return 0;
}

$ ./fcntl_F_DUPFD_test 
5
0

#include <fcntl.h>
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>

int main()
{
    int fd = open("./test", O_RDWR | O_CREAT | O_TRUNC,
        S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);

    if (fd == -1)
    {
        perror("open failed");
    }
    else
    {
        printf("%d\n", fd);
    }

    int fdFlags = fcntl(fd, F_GETFD);
    printf("%d\n", fdFlags); // 默认未设置，值为0

    fcntl(fd, F_SETFD, FD_CLOEXEC);
    fdFlags = fcntl(fd, F_GETFD);
    printf("%d\n", fdFlags); // 已设置FD_CLOEXEC，值为1

    close(fd);
    return 0;
}

$ ./fcntl_F_GETFD_test 
3
0
1

#include <fcntl.h>
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>

int main()
{
    int fd = open("./test", O_RDWR | O_CREAT | O_TRUNC,
        S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
    if (fd == -1)
    {
        perror("open failed");
    }
    else
    {
        printf("%d\n", fd);
    }

    int flags = fcntl(fd, F_GETFL);
    if (flags < 0)
    {
        perror("fcntl failed");
    }
    switch (flags & O_ACCMODE)
    {
        case O_RDONLY:
            printf("read only\n");
            break;
        case O_WRONLY:
            printf("write only\n");
            break;
        case O_RDWR:
            printf("read and write\n");
            break;
        default:
            printf("unkown\n");
    }
    close(fd);
}

#include <sys/ioctl.h>

int ioctl(int fd, unsigned long request, ...);
// 出错返回-1