#include <ctime>
#include <iostream>
#include <string>
using namespace std;
#include <grp.h>
#include <pwd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

#define MAXSIZE 1024

// 模拟实现 ls -l 这个指令
// -rwxrwxrwx 1 lzx0626 lzx0626 107 Jul 15 09:40 ls-l.cpp

int main(int argc, char const *argv[]) {
    if (argc < 2) {
        cout << "usage: " << argv[0] << " <filename>" << endl;
        return -1;
    }

    struct stat statbuf;

    // 通过stat()函数获取文件的信息
    int ret = stat(argv[1], &statbuf);
    if (ret == -1) {
        perror("stat");
        return -1;
    }

    // 获取文件类型和文件权限 st_mode变量
    string perms;  // 保存文件类型和权限的字符串
    mode_t _mode = statbuf.st_mode;
    // 获得文件类型和掩码 -S_IFMT 相与
    switch (_mode & S_IFMT) {
    case S_IFSOCK:
        perms.append("s");
        break;
    case S_IFLNK:
        perms.append("1");
        break;
    case S_IFREG:
        perms.append("-");
        break;
    case S_IFBLK:
        perms.append("b");
        break;
    case S_IFDIR:
        perms.append("d");
        break;
    case S_IFCHR:
        perms.append("c");
        break;
    case S_IFIFO:
        perms.append("p");
        break;
    default:
        perms.append("?");
        break;
    }

    // 判断文件访问权限 Users Group Others
    // Users
    perms.append((_mode & S_IRUSR) ? "r" : "-");
    perms.append((_mode & S_IWUSR) ? "w" : "-");
    perms.append((_mode & S_IXUSR) ? "x" : "-");
    // Group
    perms.append((_mode & S_IRGRP) ? "r" : "-");
    perms.append((_mode & S_IWGRP) ? "w" : "-");
    perms.append((_mode & S_IXGRP) ? "x" : "-");
    // Others
    perms.append((_mode & S_IROTH) ? "r" : "-");
    perms.append((_mode & S_IWOTH) ? "w" : "-");
    perms.append((_mode & S_IXOTH) ? "x" : "-");

    // 获取硬连接数
    nlink_t link_num = statbuf.st_nlink;

    // 文件所有者
    // 这个函数可以通过用户uid获得用户名称
    string _User = getpwuid(statbuf.st_uid)->pw_name;

    // 文件所在组
    // 这个函数通过组gid获得名称
    string _Group = getgrgid(statbuf.st_gid)->gr_name;

    // 文件大小
    off_t _size = statbuf.st_size;

    // 获取修改时间
    // ctime()函数可以将时间差值转化为本地时间
    string _mtime = string(ctime(&statbuf.st_mtime));
    // 这个时间格式化之后回车换行了，将其去掉
    _mtime.pop_back();

    // 输出
    char ret_buf[MAXSIZE];
    // 这个函数可以往字符串中填充
    sprintf(ret_buf, "%s %ld %s %s %ld %s %s", perms.c_str(), link_num, _User.c_str(), _Group.c_str(),
            _size, _mtime.c_str(), argv[1]);

    cout << ret_buf << endl;

    return 0;
}

#include <pwd.h>
struct passwd *getpwuid(uid_t uid);

#include <grp.h>
struct group *getgrgid(gid_t gid);

#include <time.h>
char *ctime(const time_t *timep);

#include <unistd.h>
int access(const char *pathname, int mode);
// 作用：用来判断某个文件是否有某个权限，或者判断文件是否存在
// 参数：
// pathname：文件路径
// mode：
    // R_OK 是否有读权限
    // W_OK 是否有写权限
    // X_OK 是否有执行权限
    // F_OK 文件是否存在
// 返回值：
// 成功 返回0
// 失败(没有这个权限) 返回-1，并且修改errno

#include <iostream>
using namespace std;
#include <unistd.h>

int main() {
    int ret = access("1.txt", F_OK);
    if (ret == -1) {
        perror("access");
        return -1;
    }

    cout << "file exists." << endl;

    return 0;
}

#include <sys/stat.h>
int chmod(const char *pathname, mode_t mode);
// 作用：修改文件权限
// 参数：
//     pathname：文件路径
//     mode：需要修改的权限值，八进制的数
// 返回值：
//     成功返回0
//     失败返回-1

#include <iostream>
using namespace std;
#include <sys/stat.h>

int main() {
    int ret = chmod("1.txt", 0777);
    if (ret == -1) {
        perror("chmod");
        return -1;
    }

    return 0;
}

#include <unistd.h>

int chown(const char *pathname, uid_t owner, gid_t group);
int fchown(int fd, uid_t owner, gid_t group);
int lchown(const char *pathname, uid_t owner, gid_t group);

#include <sys/types.h>
#include <unistd.h>

int truncate(const char *path, off_t length);
// 作用：缩减或者扩展文件尺寸到达指定的大小
// 参数:
    // path：文件路径
    // length：需要最终文件变成的大小
// 返回值：
    // 成功 0
    // 失败 -1

#include <iostream>
using namespace std;
#include <sys/types.h>
#include <unistd.h>

int main() {
    int ret = truncate("b.txt", 5);
    if (ret == -1) {
        perror("truncate");
        return -1;
    }

    return 0;
}

    #include <sys/stat.h>
    #include <sys/types.h>

    int mkdir(const char *pathname, mode_t mode);
// 作用：去创建一个目录
// 参数：
//     pathname：目录名称
//     mode：权限，八进制数
// 返回值：
//     成功 0
//     失败 -1

#include <iostream>
using namespace std;
#include <sys/stat.h>
#include <sys/types.h>

int main() {
    int ret = mkdir("fuck", 0777);
    if (ret == -1) {
        perror("mkdir");
        return -1;
    }

    return 0;
}

#include <unistd.h>
int rmdir(const char *pathname);

#include <stdio.h>
int rename(const char *oldpath, const char *newpath);
//一看就懂了

#include <iostream>
using namespace std;

int main() {
    int ret = rename("fuck", "fuckyou");
    if (ret == -1) {
        perror("rename");
        return -1;
    }

    return 0;
}

#include <unistd.h>
int chdir(const char *path);
//作用：修改进程的工作目录
    //比如在 /home/newcoder 启动了一个可执行程序 a.out，进程的工作目录 /home/newcoder
//参数：
    //path：需要修改到的工作目录


#include <unistd.h>
char *getcwd(char *buf, size_t size);
//作用：获取当前工作目录
//参数：
    //buf：往数组里存，传出参数
    //size：数组的大小
//返回值：返回的是指向的一块内存，这个数据就是第一个参数buf

#include <iostream>
using namespace std;
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

#include <cstring>

int main() {
    // 获取当前工作目录
    char buf[1024] = {0};

    getcwd(buf, sizeof(buf));
    cout << buf << endl;

    // 修改工作目录
    int ret = chdir("./fuckyou");
    if (ret == -1) {
        perror("chdir");
        return -1;
    }

    // 代码执行到这里把工作目录修改之后在该目录之下进行下一步操作
    // 只在程序运行的时候生效，程序结束后终端当中的工作目录不会改变!
    
    // 创建新的文件
    int fd = open("1.txt", O_RDWR | O_CREAT, 0664);
    if (fd == -1) {
        perror("open");
        return -1;
    }

    close(fd);

    char Null_buf[1024] = {0};
    strncpy(buf, Null_buf, sizeof(buf));

    getcwd(buf, sizeof(buf));
    cout << buf << endl;

    return 0;
}

#include <dirent.h>
#include <sys/types.h>
DIR *opendir(const char *name);
//参数：
    //name：需要打开的目录的名称
//返回值：
    //DIR * 类型，理解为目录流
    //错误 返回nullptr

//打开目录
#include <dirent.h>
#include <sys/types.h>
DIR *opendir(const char *name);
//参数：
    //name：需要打开的目录的名称
//返回值：
    //DIR * 类型，理解为目录流
    //错误 返回nullptr

//读取目录中的数据
#include <dirent.h>
struct dirent *readdir(DIR *dirp);
//参数：
    //dirp是通过opendir返回的结果
//返回值：
    //struct dirent 代表读取到的文件的信息
    //读取到了文件末尾或者失败了，返回Null，区别是读到文件末尾不会修改errno，失败会修改

//关闭目录
#include <dirent.h>
int closedir(DIR *dirp);

#include <iostream>
#include <string>
using namespace std;
#include <dirent.h>
#include <sys/types.h>

// 递归函数，用于获取目录下所有普通文件的个数
void getFileNum(string path, int& num) {
    // 打开目录
    DIR* _dir = opendir(path.c_str());
    if (_dir == nullptr) {
        perror("opendir");
        exit(0);
    }

    // 读取目录数据
    // 循环读取，因为// 注意这个16的由来dir是一个一个读取的，读到末尾返回Null
    struct dirent* _ptr;

    while ((_ptr = readdir(_dir)) != nullptr) {
        // 获取名称
        // Shell终端中有当前目录 ./ 和 上级目录 ../，这两个不能拿来递归，需要忽略
        string _dname = _ptr->d_name;
        if (_dname == "." || _dname == "..")
            continue;

        // 判断是普通文件还是目录
        if (_ptr->d_type == DT_DIR)
            // 目录需要拼接一下
            getFileNum(path + "/" + _dname, num);
        else if (_ptr->d_type == DT_REG)
            ++num;
    }

    // 关闭目录
    closedir(_dir);
}

int main(int argc, char* const argv[]) {
    // 读取某个目录下所有普通文件的个数
    if (argc < 2) {
        cout << "usage: " << argv[0] << " <path>" << endl;
        return -1;
    }

    int num = 0;
    getFileNum(argv[1], num);
    cout << num << endl;

    return 0;
}

#include <unistd.h>
int dup(int oldfd);
// 作用：复制一个新的文件描述符，他们是指向同一个文件的，只是用了两个文件描述符
// 新的文件描述符会使用空闲的文件描述符表中最小的那个!!!

#include <iostream>
#include <string>
using namespace std;
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
    int fd = open("1.txt", O_RDWR | O_CREAT, 0664);
    if (fd == -1) {
        perror("open");
        return -1;
    }

    int fd1 = dup(fd);
    if (fd1 == -1) {
        perror("dup");
        return -1;
    }

    printf("fd : %d , fd1 : %d\n", fd, fd1);

    // 关闭fd，现在只有fd1指向文件
    close(fd);

    // 通过fd1来写该文件
    string fuck = "hello world";
    int ret = write(fd1, fuck.c_str(), fuck.size());
    if (ret == -1) {
        perror("write");
        return -1;
    }

    return 0;
}

#include <unistd.h>

int dup2(int fd1, int fd2);
// 作用：重定向文件描述符
    // fd1指向a.txt，fd2指向b.txt
    // 调用函数成功后，fd2和b.txt的连接做close(fd1仍指向a.txt)，fd2指向a.txt
    // fd1必须是一个有效的文件描述符
    // 如果相同则相当于什么都没做
// 返回值：
    // fd2，他们都指向的是fd1之前指向的文件

#include <iostream>
#include <string>
using namespace std;
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
    int fd = open("2.txt", O_RDWR | O_CREAT, 0664);
    if (fd == -1) {
        perror("open");
        return -1;
    }

    int fd1 = open("3.txt", O_RDWR | O_CREAT, 0664);
    if (fd1 == -1) {
        perror("open");
        return -1;
    }

    printf("fd : %d , fd1 : %d\n", fd, fd1);

    int fd2 = dup2(fd, fd1);
    // 现在fd本来指向 2.txt ，现在fd仍指向2.txt
    // fd1本来 3.txt，现在指向到了 2.txt
    if (fd2 == -1) {
        perror("dup2");
        return -1;
    }

    // 通过fd1去写数据，实际操作的是2.txt
    // 通过fd一样指向2.txt
    string fuck = "hello world";
    int ret = write(fd1, fuck.c_str(), fuck.size());
    if (ret == -1) {
        perror("write");
        return -1;
    }

    printf("fd : %d , fd1 : %d , fd2: %d\n", fd, fd1, fd2);

    return 0;
}

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

int fcntl(int fd, int cmd, ...); ...当中是可变参数
// 参数：
//     fd：需要操作的文件描述符
//     cmd：表示对文件描述符进行如何操作
//         F_DUPFD 复制文件描述符，复制的是第一个参数，得到一个新的文件描述符(返回值)
//             int ret = fcntl(fd,F_DUPFD);
//         F_GETFL 获取指定文件描述符的文件状态flag
//             获取的flag和我们通过open函数传递的flag是一个东西
//         F_SETFL 设置文件描述符的文件状态flag
//             必选项：O_RDONLY O_WRONLY O_RDWR 不可以被修改
//             可选项：O_APPEND O_NONBLOCK
//                 O_APPEND 表示追加数据
//                 O_NONBLOCK 设置成非阻塞
//                     阻塞和非阻塞：描述的是函数调用的行为

#include <iostream>
using namespace std;
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
    // 1.复制文件描述符，得到两个文件描述符(int值不同)指向同一个文件，可以进行的操作相同
    // int fd = open("1.txt", O_RDONLY);
    // if (fd == -1) {
    //     perror("open");
    //     return -1;
    // }

    // int ret = fcntl(fd, F_DUPFD);
    // if (ret == -1) {
    //     perror("fcntl");
    //     return -1;
    // }

    // 2.修改或者获取文件描述符的文件状态flag
    // 这里必须读写权限都要有才行
    int fd = open("1.txt", O_RDWR, 0664);
    if (fd == -1) {
        perror("open");
        return -1;
    }

    // 修改文件描述符的flag，加入O_APPEND这个标记
    // 首先获得
    int _flag = fcntl(fd, F_GETFL);
    if (_flag == -1) {
        perror("fcntl");
        return -1;
    }

    // 然后修改
    int ret = fcntl(fd, F_SETFL, _flag | O_APPEND);
    if (ret == -1) {
        perror("fcntl");
        return -1;
    }

    // 然后进行追加
    string fuck = "你好";
    ret = write(fd, fuck.c_str(), fuck.size());
    if (ret == -1) {
        perror("write");
        return -1;
    }

    close(fd);

    return 0;
}

#include <unistd.h>
int unlink(const char *pathname); // linux系统的函数

#include <stdio.h>
int remove(const char *pathname); // 标准C库的函数

#include <unistd.h>

pid_t fork(void);
//作用：用于创建子进程
//返回值：
    //fork()的返回值会返回两次，一次是在父进程中，一次是在子进程中
    //为什么会走两次呢？因为这个cpp文件编译出来是一个可执行文件 a.out，这个文件执行后是进程 ./a.out，自然创建出来的也是 ./a.out进程，也就是走的是这个cpp程序
    //但是注意一点：子进程是不会执行fork()函数的，因为fork()函数是父进程执行的，但是他会持有返回值，在子进程当中就是0
    //成功 父进程中返回子进程的pid，子进程中返回0
    //失败 父进程中返回-1，没有子进程被创建，然后修改errno

#include <iostream>
using namespace std;
#include <unistd.h>

int main() {
    int pid = fork();
    if (pid == -1) {
        perror("fork");
        return -1;
    }

    // 判断是父进程还是子进程
    if (pid > 0) {  // 父进程走，返回的是创建的子进程编号
        cout << pid << endl;
        printf("I am parent process, pid : %d , ppid : %d\n", getpid(), getppid());
    } else if (pid == 0)  // 子进程走
        printf("I am child process, pid : %d , ppid : %d\n", getpid(), getppid());

    // for
    for (int i = 0; i < 3; ++i) {
        sleep(1);
        cout << i << endl;
    }

    return 0;
}

#include <unistd.h>
int execl(const char *pathname, const char *arg, ... , (char *) NULL );
//参数：
    //path：指定的执行的可执行文件的路径，例如：a.out 推荐写绝对路径
    //arg：字符串，是可执行文件所需要的参数列表
        //第一个参数(arg当中的第一个参数!!)一般没有作用，为了方便，一般写的是可执行的程序的名称
        //从第二参数开始往后，就是程序执行所需要的参数列表
        //参数最后需要以NULL结束(哨兵)

//返回值：
    //只有调用错误，才会有返回值，为-1，且设置errno
    //调用成功不会有返回值，

#include <iostream>
using namespace std;
#include <unistd.h>

int main() {
    // 创建一个子进程，在子进程中执行exec函数族当中的函数
    pid_t child_pid = fork();
    if (child_pid == -1) {
        perror("fork");
        return -1;
    }

    if (child_pid > 0) {
        // 父进程
        printf("I am parent process , pid : %d\n", getpid());
        sleep(1);
    } else if (child_pid == 0) {
        // 子进程
        execl("hello", "hello", nullptr);
        printf("I am child process , pid : %d\n", getpid());
    }

    for (int i = 0; i < 3; ++i)
        printf("i = %d , pid = %d\n", i, getpid());

    return 0;
}

#include <iostream>
using namespace std;
#include <unistd.h>

int main() {
    // 创建一个子进程，在子进程中执行exec函数族当中的函数
    pid_t child_pid = fork();
    if (child_pid == -1) {
        perror("fork");
        return -1;
    }

    if (child_pid > 0) {
        // 父进程
        printf("I am parent process , pid : %d\n", getpid());
        sleep(1);
    } else if (child_pid == 0) {
        // 子进程
        // execl("hello", "hello", nullptr);

        // 可以执行linux系统自己的可执行程序，比如ps命令(/usr/bin/ps)
        execl("/usr/bin/ps", "ps", "aux", nullptr);

        printf("I am child process , pid : %d\n", getpid());
    }

    for (int i = 0; i < 3; ++i)
        printf("i = %d , pid = %d\n", i, getpid());

    return 0;
}

#include <unistd.h>
int execlp(const char *file, const char *arg, ... , (char *) NULL );
//参数：
    //会到环境变量中查找可执行文件，找到了就执行，找不到就不成功!!!
    //file：需要执行的可执行文件的文件名，不包含路径!!!


    //arg：字符串，是可执行文件所需要的参数列表
        //第一个参数(arg当中的第一个参数!!)一般没有作用，为了方便，一般写的是可执行的程序的名称
        //从第二参数开始往后，就是程序执行所需要的参数列表
        //参数最后需要以NULL结束(哨兵)

//返回值：
    //只有调用错误，才会有返回值，为-1，且设置errno
    //调用成功不会有返回值

#include <iostream>
using namespace std;
#include <unistd.h>

int main() {
    // 创建一个子进程，在子进程中执行exec函数族当中的函数
    pid_t child_pid = fork();
    if (child_pid == -1) {
        perror("fork");
        return -1;
    }

    if (child_pid > 0) {
        // 父进程
        printf("I am parent process , pid : %d\n", getpid());
        sleep(1);
    } else if (child_pid == 0) {
        // 子进程
        // execl("hello", "hello", nullptr);

        // 可以执行linux系统自己的可执行程序，比如ps命令(/usr/bin/ps)
        execlp("ps", "ps", "aux", nullptr);

        printf("I am child process , pid : %d\n", getpid());
    }

    for (int i = 0; i < 3; ++i)
        printf("i = %d , pid = %d\n", i, getpid());

    return 0;
}

#include <iostream>
using namespace std;
#include <unistd.h>

int main() {
    cout << "hello" << endl;
    cout << "world";

    // exit(0);
    _exit(0);

    return 0;
}

cout << "hello" << endl;
cout << "world";

// exit(0);
_exit(0);

#include <iostream>
using namespace std;
#include <unistd.h>

int main() {
    cout << "hello";

    sleep(2);

    return 0;
}

#include <iostream>
using namespace std;
#include <unistd.h>

int main() {
    int pid = fork();
    if (pid == -1) {
        perror("fork");
        return -1;
    }

    // 判断是父进程还是子进程
    if (pid > 0) {  // 父进程走，返回的是创建的子进程编号
        printf("I am parent process, pid : %d , ppid : %d\n", getpid(), getppid());
    } else if (pid == 0) {  // 子进程走
        sleep(1);           // 强制让子进程睡1秒，让父进程跑完，子进程称为孤儿进程
        printf("I am child process, pid : %d , ppid : %d\n", getpid(), getppid());
    }

    // for
    for (int i = 0; i < 3; ++i) {
        printf("i : %d , pid : %d\n", i, getpid());
    }

    return 0;
}

#include <iostream>
using namespace std;
#include <unistd.h>

int main() {
    int pid = fork();
    if (pid == -1) {
        perror("fork");
        return -1;
    }

    // 判断是父进程还是子进程
    if (pid > 0) {   // 父进程走，返回的是创建的子进程编号
        while (1) {  // 强制让父进程一直循环，不退出，让子进程结束，父进程没办法回收他的资源
            printf("I am parent process, pid : %d , ppid : %d\n", getpid(), getppid());
            sleep(1);
        }
    } else if (pid == 0) {  // 子进程走
        printf("I am child process, pid : %d , ppid : %d\n", getpid(), getppid());
    }

    return 0;
}

#include <sys/wait.h>

pid_t wait(int *wstatus);
//功能：等待任意一个子进程结束，如果任意一个子进程结束了，此函数会回收这个子进程的资源
//参数：int *wstatus
    //进程退出时候的状态信息，传入的是一个int类型的地址，传出参数
//返回值：
    //成功 返回被回收的子进程的id
    //失败 -1(所有的子进程都结束，调用函数失败) 并且修改errno

//调用wait()函数，进程会阻塞，知道他的一个子进程退出或者收到一个不能被忽略的信号，这个时候才被唤醒
//如果没有子进程，这个函数立刻返回-1；如果子进程都已经结束了，也会返回-1

#include <iostream>
using namespace std;
#include <sys/wait.h>
#include <unistd.h>

int main() {
    // 有一个父进程，创建5个子进程
    pid_t pid;

    for (int i = 0; i < 5; ++i) {
        pid = fork();

        if (pid == -1) {
            perror("fork");
            return -1;
        }

        if (pid == 0)  // 说明是子进程，如果不加这行代码，子进程也会走for循环，他也会fork()产生更多的孙子进程，重孙进程等等
            break;
    }

    if (pid > 0) {
        // 父进程
        while (1) {
            printf("parent , pid = %d\n", getpid());

            // int ret = wait(NULL);

            int status;
            int ret = wait(&status);

            printf("child die,pid = %d\n", ret);

            sleep(1);
        }
    } else if (pid == 0) {
        // 子进程
        printf("child , pid = %d\n", getpid());
        sleep(1);

        exit(0);
    }

    return 0;
}

#include <iostream>
using namespace std;
#include <sys/wait.h>
#include <unistd.h>

int main() {
    // 有一个父进程，创建5个子进程
    pid_t pid;

    for (int i = 0; i < 5; ++i) {
        pid = fork();

        if (pid == -1) {
            perror("fork");
            return -1;
        }

        if (pid == 0)  // 说明是子进程，如果不加这行代码，子进程也会走for循环，他也会fork()产生更多的孙子进程，重孙进程等等
            break;
    }

    if (pid > 0) {
        // 父进程
        while (1) {
            printf("parent , pid = %d\n", getpid());

            // int ret = wait(NULL);

            int status;
            int ret = wait(&status);

            if (ret == -1)  // 没有子进程
                break;

            // 有子进程，回收了子进程的资源
            if (WIFEXITED(status)) {  // 是不是正常退出
                printf("退出的状态码: %d\n", WEXITSTATUS(status));
            } else if (WIFSIGNALED(status)) {  // 是不是异常退出
                printf("被哪个信号干掉了: %d\n", WTERMSIG(status));
            }

            printf("child die,pid = %d\n", ret);

            sleep(1);
        }
    } else if (pid == 0) {
        // 子进程
        // while(1) {
        printf("child , pid = %d\n", getpid());
        sleep(1);
	    // }
        
        exit(0);
    }

    return 0;
}