2022-06-04

字数统计: 7.5k字 | 阅读时长: 32分

Linux服务器项目-2

1.4 Makefile

概述：

一个工程中的源文件不计其数，其按类型、功能、模块分别放在若干个目录中。

Makefile 文件定义了一系列的规则来指定哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为 Makefile 文件就像一个 Shell 脚本一样，也可以执行操作系统的命令。

Makefile 带来的好处就是“自动化编译” ”，一旦写好，只需要一个 make命令。

文件命名：makefile或者Makefile

一个Makefile文件中可以有一个或者多个规则。

目标…: 依赖 …

命令(Shell命令)

…
- 目标：最终要生成的文件（伪目标除外）
- 依赖：生成目标所需要的文件或是目标
- 命令：通过执行命令对依赖操作生成目标（命令前必须 Tab 缩进）

比如前面的加减乘除的例子Makefile的写法为：

1 2	app:sub.c add.c mult.c div.c main.c gcc sub.c add.c mult.c div.c main.c -o app

工作原理：

命令在执行之前，需要先检查规则中的依赖是否存在

如果存在，执行命令
如果不存在，向下检查其它的规则，检查有没有一个规则是用来生成这个依赖的，如果找到了，则执行该规则中的命令，Makefile 中的其它规则一般都是为第一条规则服务的。

检测更新，在执行规则中的命令时，会比较目标和依赖文件的时间，如果Makefile中需要的文件有更新，也就是依赖文件的时间晚于目标文件，执行make时才会重新运行Makefile中的指令。

变量:

自定义变量

变量名 = 变量值 var = hello
预定义变量

AR：归档维护程序的名称，默认值为 ar

CC : C编译器的名称，默认值为 cc

CXX : C++编译器的名称，默认值为 g++

$@ :目标的完整名称

$< :第一个依赖文件的名称

$^:所有的依赖文件
获取变量的值

$(变量名)

有了这些变量，就可以进行如下的简化：

#原来的方式
app:main.c a.c b.c
	gcc -c main.c a.c b.c -o app
#简化的方式
app:main.c a.c b.c
	$(CC) -c $^ -o $@

模式匹配：

#原来的方式
add.o:add.c
	gcc -c add.c -o add.o
#使用模式匹配，%是通配符，匹配一个字符串，匹配上就可以执行下面的操作
%.o:%.c
	gcc -c $< -o $@

函数：

$(wildcard PATTERN...)

功能：获取指定目录下指定类型的文件列表

参数： PATTERN 指的是某个或多个目录下的对应的某种类型的文件。如果有多个目录，一般使用空格间隔

返回：得到的若干个文件的文件列表，文件名之间使用空格间隔
示例：$(wildcard *.c ./sub/*.c)

返回值格式: a.c b.c c.c d.c e.c f.c，即路径下的各个文件名

$(patsubst <pattern>,<replacement>,<text>)
功能：查找 < 中的单词单词以“空格”、“ Tab ”或“回车”“换行”分隔是否符合模式 < pattern>，如果匹配的话，则以 < 替换。

示例：$(patsubst %.c, %.o, x.c bar.c)；返回值格式: x.o bar.o

最终版本的Makefile：

#定义变量
src=$(wildcard ./*.c)
objs=$(patsubst %.c, %.o, $(src))
target=app
$(target):$(objs)
	$(CC) $(objs) -o $(target)
%.o:%.c
	$(CC) -c $< -o $@

.PHONY:clean #生成一个伪目标，这个目标不需要和现有文件进行时间的对比
#touch clean可以创建一个带有时间信息的clean文件
clean:
	rm $(objs) app -f

1.5 GDB调试

概述：GDB是GNU提供的一个调试工具，同GCC组成了一套完整的开发环境，GDB是Linux和许多类Unix系统中的标准开发环境。

主要功能：

启动程序，可以按照自定义的要求随心所欲的运行程序
可让被调试的程序在所指定的调置的断点处停住（断点可以是条件表达式）
当程序被停住时，可以检查此时程序中所发生的事
可以改变程序，将一个 BUG 产生的影响修正从而测试其他 BUG

通常，在为了调试而编译时，会关闭编译器的优化选项(-O)，打开调试选项(-g)，另外，Wall在尽量不影响程序行为的情况下打开所有warning，避免不必要的bug。

-g 选项的作用是在可执行文件中加入源代码的信息，比如可执行文件中第几条机器指令对应源代码的第几行，但并不是把整个源文件嵌入到可执行文件中，所以在调试时必须保证 gdb 能找到源文件。

加入-g选项后的文件大小明显大于没有加入此选项的文件。

###########基础操作
#经过以下操作即可进入gdb,退出gdb
gcc test.c -o test -g
gdb test
quit
#设置参数,获取设置参数
set args 10 20
show args
#帮助
help/help all
###########查看代码
#查看当前文件代码
list/l #从默认位置显示
list/l 行号 #从指定的行显示
list/l 函数名 #从指定的函数显示
#查看非当前文件代码
list/l 文件名 #行号
list/l 文件名 #函数名
#设置显示的行数
show list/listsize
set list/listsize #行数
############断点操作
#设置断点,注意设置在第n行的断点不执行第n行
b/break 行号
b/break 函数名
b/break 文件名 行号
b/break 文件名
#查看和删除断点
i/info b/break
d/del/delete 断点编号
#设置断点无效，生效
dis/disable 断点编号
ena/enable 断点编号
#设置条件断点（一般用在循环的位置）
b/break 10 if i==5
#############调试命令
#运行 GDB 程序
start #程序停在第一行
run #遇到断点才停
#继续运行，到下一个断点停
c/continue
#向下执行一行代码，不会进入函数体
n/next
#变量操作
p/print 变量名(打印变量值)
ptype 变量名(打印变量类型)
#向下单步调试(遇到函数进入函数体)
s/step
finish #跳出函数体
#自动变量操作
display 变量名(自动打印指定变量的值)
i/info display
undisplay 编号
#其它操作
set var 变量名 变量值 循环中用的较多
until (跳出循环)

1.6 文件IO概述

文件角度的IO：输入就是将内存中的内容输到文件中，输出就是将文件的内容输到内存中。

内存角度的IO：输入就是将文件中的内容输到内存中，输出就是将内存的内容输到文件中。

程序的跨平台：调用不同的库函数时需要不同平台的API执行。

标准C库IO和系统级IO的比较：

标准C库的IO执行时会调用系统的API，系统级的IO更靠近底层。但是标准C库的效率更高。

标准C库使用fopen打开返回一个文件的指针，FILE *；可以通过man 3 函数名查看函数的信息。而Linux系统的函数可以通过man 2 函数名查看

而系统级的文件IO实际上是操作文件描述符对应的文件。

有了这个文件指针，就可以通过fread和fwrite向文件读写数据

linux中的FILE类型实际上是_IO_FILE这个结构体的别名。_IO_FILE结构体中有一个_fileno变量即为文件描述符，文件指针就是通过文件描述符找到文件的。文件描述符在内核区，由内核中的PCB(进程控制块)管理。PCB是一个非常复杂的结构体，将需要管理的数据放在PCB中。

1
2

//ptr是写入的文件的数据，size是写入数据块的大小，nmemb是每个块的数量，比如一个字符串每个数据块就是一个字符，FILE *stream文件指针用来操作文件。File中维护了文件描述符(整型值)，文件读写指针和I/O缓存区(内存地址)
size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);

利用标准C库IO函数文件向内存中写内容时，先将自身的信息写入到缓存区中，缓存区满了，或者调用fflush，或者正常关闭文件时(fclose，return，exit)时将内容写到内存中。默认的Buffer大小是8192byte(8k)

文件IO和标准C库的IO函数的应用场景也不一样，在网络通信这种对时延要求高的系统中，使用文件IO更好。对于向磁盘读写文件来说，使用标准C库函数由于用到了缓存区，效率更高。

进程：为了运行程序操作系统为程序分配了一些资源，同时创建一个进程。程序只是磁盘上的代码，不占用内存空间，而进程(运行中的程序)会将自身信息加载到内存中。

虚拟地址空间:

虚拟地址空间最终会被CPU中的逻辑管理单元MMU映射到物理内存上。

受保护的地址：包括NULL，nullptr等；

.text：程序运行时加载到这部分，都是二进制机器指令。

堆空间：通过new，malloc等创建出的空间，从低地址向高地址存；栈空间：从高地址向低地址存。

查看环境变量：env

内核区普通用户没有读写权限，想要操作内核就需要系统调用，即调用Linux系统的API。

文件描述符：

PCB中有文件描述符表，其用数组来描述，前三个文件描述符已经被占用，标准输入，标准输出和标准错误。不同的文件描述符可以对应同一个文件，比如要对一个文件进行打开，读，写；这些处理的文件描述符都是不一样的。

Linux具有一切皆文件的思想，IO设备实际上也可以抽象为设备文件。

1.7 Linux系统IO函数

1.7.1 open函数

标准C库的IO函数实际上和Linux系统的IO函数是相对应的。比如fopen对应open函数。

/*	open函数的使用:打开一个已经存在的文件
    #include <sys/types.h> //定义了一些需要的数据类型
    #include <sys/stat.h> //定义了一些获取文件属性的函数
    #include <fcntl.h>//定义了flag中的一些宏，包括读写权限等等
    //打开一个已经存在的文件
    int open(const char *pathname, int flags);
        参数：
            - pathname:打开文件的路径
            - flags:对文件的操作权限设置 O_RDONLY, O_WRONLY, or O_RDWR(这三个是互斥的)
        返回值：
            如果产生错误返回-1，否则返回新的文件描述符fd
    
    errno:属于Linux系统函数库，里面是全局变量，记录的是最近的错误号
    #include <stdio.h>
    void perror(const char *s);//打印errno对应的错误描述，s参数是用户描述，比如hello，最终输出hello:xxx(实际的错误描述)

    //创建一个新的文件
    int open(const char *pathname, int flags, mode_t mode); //不是重载，而是通过可变参数实现的
*/

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
int main(){
    int fd = open("a.txt", O_RDONLY);
    if(fd == -1){
        perror("open"); //open是用户描述
    }
    //printf("%d\n", fd); 输出3
    //关闭
    close(fd);
    return 0;
}

通过ll命令显示出的文件的权限包括10个字符，第一个字符表示文件的类型，后面的几个表示文件的权限，每三个一组。前三个表示当前用户对文件的权限，中间三个表示当前文件的组对文件的权限，最后三个表示其他组对文件的权限。比如-rw-r--r--如果有读，写，可执行的权限，对应的就是7。三组都有读，写，可执行的权限，就对应777。

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

    int open(const char *pathname, int flags, mode_t mode);
        参数：
            - pathname：要创建的文件的路径
            - flags：对文件的操作权限和其他的设置
                - 必选项：O_RDONLY,  O_WRONLY, O_RDWR  这三个之间是互斥的
                - 可选项：O_CREAT 文件不存在，创建新文件
            - mode：八进制的数，表示创建出的新的文件的操作权限，比如：0775,如果有读，写，可执行的权限，对应的就是777
            最终的权限是：mode & ~umask umask普通用户是0002,root用户是0022
            0777   ->   111111111
        &   0775   ->   111111101
        ----------------------------
                        111111101
        按位与：0和任何数都为0
        umask的作用就是抹去某些权限。

        flags参数是一个int类型的数据，占4个字节，32位。
        flags 32个位，每一位就是一个标志位。

*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h> //close用到
#include <stdio.h> //perror用到

int main() {

    // 创建一个新的文件
    int fd = open("create.txt", O_RDWR | O_CREAT, 0777); // "|"代表按位或，相当于将CREAT标志位和RDWR标志位都加在flag里

    if(fd == -1) {
        perror("open");
    }

    // 关闭
    close(fd);
    return 0;
}

1.7.2 read，write函数

利用read和write函数实现文件拷贝

/*  
    #include <unistd.h>
    ssize_t read(int fd, void *buf, size_t count);
        参数：
            - fd：文件描述符，open得到的，通过这个文件描述符操作某个文件
            - buf：需要读取数据存放的地方，数组的地址（传出参数）
            - count：指定的数组的大小
        返回值：
            - 成功：
                >0: 返回实际的读取到的字节数
                =0：文件已经读取完了
            - 失败：-1 ，并且设置errno

    #include <unistd.h>
    ssize_t write(int fd, const void *buf, size_t count);
        参数：
            - fd：文件描述符，open得到的，通过这个文件描述符操作某个文件
            - buf：要往磁盘写入的数据，数组
            - count：要写的数据的实际的大小
        返回值：
            成功：实际写入的字节数
            失败：返回-1，并设置errno
*/
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main() {

    // 1.通过open打开english.txt文件
    int srcfd = open("english.txt", O_RDONLY);
    if(srcfd == -1) {
        perror("open");
        return -1;
        //exit
    }

    // 2.创建一个新的文件（拷贝文件）
    int destfd = open("cpy.txt", O_WRONLY | O_CREAT, 0664);
    if(destfd == -1) {
        perror("open");
        return -1;
    }

    // 3.频繁的读写操作
    char buf[1024] = {0};
    int len = 0;
    while((len = read(srcfd, buf, sizeof(buf))) > 0) {
        write(destfd, buf, len);
    }
    
    // 4.关闭文件
    close(destfd);
    close(srcfd);
    return 0;
}

1.7.3 lseek函数

/*  
    标准C库的函数
    #include <stdio.h>
    int fseek(FILE *stream, long offset, int whence);

    Linux系统函数
    #include <sys/types.h>
    #include <unistd.h> //unix标准头文件
    off_t lseek(int fd, off_t offset, int whence);
        参数：
            - fd：文件描述符，通过open得到的，通过这个fd操作某个文件
            - offset：偏移量
            - whence:
                SEEK_SET
                    设置文件指针的偏移量
                SEEK_CUR
                    设置偏移量：当前位置 + 第二个参数offset的值
                SEEK_END
                    设置偏移量：文件大小 + 第二个参数offset的值
        返回值：返回文件指针的位置
    作用：
        1.移动文件指针到文件头
        lseek(fd, 0, SEEK_SET);

        2.获取当前文件指针的位置
        lseek(fd, 0, SEEK_CUR);

        3.获取文件长度
        lseek(fd, 0, SEEK_END);

        4.拓展文件的长度，当前文件10b, 110b, 增加了100个字节
        lseek(fd, 100, SEEK_END)
        注意：需要写一次数据

*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
int main() {
    int fd = open("hello.txt", O_RDWR);
    if(fd == -1) {
        perror("open");
        return -1;
    }
    // 扩展文件的长度
    int ret = lseek(fd, 100, SEEK_END);
    if(ret == -1) {
        perror("lseek");
        return -1;
    }
    // 写入一个空数据
    write(fd, " ", 1);
    // 关闭文件
    close(fd);
    return 0;
}

1.7.4 stat,lstat函数

stat函数用来获取文件的信息，lstat函数用来获取软链接文件的信息

创建软链接：从b.txt到a.txt；ln -s a.txt b.txt

stat结构体内容如下：

struct stat {
dev_t st_dev; // 文件的设备编号
ino_t st_ino; // 节点
mode_t st_mode; // 文件的类型和存取的权限
nlink_t st_nlink; // 连到该文件的硬连接数目
uid_t st_uid; // 用户 ID
gid_t st_gid; // 组 ID
dev_t st_rdev; // 设备文件的设备编号
off_t st_size; // 文件字节数 文件大小
blksize_t st_blksize; // 块大小
blkcnt_t st_blocks; // 块数
time_t st_atime; // 最后一次访问时间
time_t st_mtime; // 最后一次修改时间
time_t st_ctime; // 最后一次改变时间 指属性
};

使用stat函数的例子

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

    int stat(const char *pathname, struct stat *statbuf);
        作用：获取一个文件相关的一些信息
        参数:
            - pathname：操作的文件的路径
            - statbuf：结构体变量，传出参数，用于保存获取到的文件的信息
        返回值：
            成功：返回0
            失败：返回-1 设置errno

    int lstat(const char *pathname, struct stat *statbuf); //获取软链接的信息，而不是软链接指向文件的信息
        参数:
            - pathname：操作的文件的路径
            - statbuf：结构体变量，传出参数，用于保存获取到的文件的信息
        返回值：
            成功：返回0
            失败：返回-1 设置errno

*/
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
int main() {
    struct stat statbuf;
    int ret = stat("a.txt", &statbuf);
    if(ret == -1) {
        perror("stat");
        return -1;
    }
    printf("size: %ld\n", statbuf.st_size);
    return 0;
}

通过stat函数可以实现一个和ls -l功能相同的程序

通过ls -l a.txt可以输出以下的信息：-rw-rw-r-- 1 ygtrece ygtrece 12 6月 5 02:06 a.txt

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <pwd.h>
#include <grp.h>
#include <time.h>
#include <string.h>

// 模拟实现 ls -l 指令
// -rw-rw-r-- 1 ygtrece ygtrece 12 6月   5 02:06 a.txt
int main(int argc, char * argv[]) {

    // 判断输入的参数是否正确
    if(argc < 2) {
        printf("%s filename\n", argv[0]);
        return -1;
    }

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

    // 获取文件类型和文件权限
    char perms[11] = {0};   // 用于保存文件类型和文件权限的字符串

    switch(st.st_mode & S_IFMT) { //首先是文件类型
        case S_IFLNK:
            perms[0] = 'l';
            break;
        case S_IFDIR:
            perms[0] = 'd';
            break;
        case S_IFREG:
            perms[0] = '-';
            break; 
        case S_IFBLK:
            perms[0] = 'b';
            break; 
        case S_IFCHR:
            perms[0] = 'c';
            break; 
        case S_IFSOCK:
            perms[0] = 's';
            break;
        case S_IFIFO:
            perms[0] = 'p';
            break;
        default:
            perms[0] = '?';
            break;
    }

    // 判断文件的访问权限

    // 文件所有者
    perms[1] = (st.st_mode & S_IRUSR) ? 'r' : '-';
    perms[2] = (st.st_mode & S_IWUSR) ? 'w' : '-';
    perms[3] = (st.st_mode & S_IXUSR) ? 'x' : '-';

    // 文件所在组
    perms[4] = (st.st_mode & S_IRGRP) ? 'r' : '-';
    perms[5] = (st.st_mode & S_IWGRP) ? 'w' : '-';
    perms[6] = (st.st_mode & S_IXGRP) ? 'x' : '-';

    // 其他人
    perms[7] = (st.st_mode & S_IROTH) ? 'r' : '-';
    perms[8] = (st.st_mode & S_IWOTH) ? 'w' : '-';
    perms[9] = (st.st_mode & S_IXOTH) ? 'x' : '-';

    // 硬连接数
    int linkNum = st.st_nlink;

    // 文件所有者
    char * fileUser = getpwuid(st.st_uid)->pw_name;

    // 文件所在组
    char * fileGrp = getgrgid(st.st_gid)->gr_name;

    // 文件大小
    long int fileSize = st.st_size;

    // 获取修改的时间
    char * time = ctime(&st.st_mtime); //ctime将日期和时间转换为字符串

    char mtime[512] = {0};
    strncpy(mtime, time, strlen(time) - 1);//去掉换行符，strncpy函数用于将指定长度的字符串复制到字符数组中
    char buf[1024];
    sprintf(buf, "%s %d %s %s %ld %s %s", perms, linkNum, fileUser, fileGrp, fileSize, mtime, argv[1]);//把格式化的数据写入某个字符串中
    printf("%s\n", buf);
    return 0;
}

1.7.5 文件属性操作函数

int access(const char *pathname, int mode);
int chmod(const char *filename, int mode);
int chown(const char *path, uid_t owner, gid_t group);
int truncate(const char *path, off_t length);

access函数的使用：判断文件是否存在，或者文件的权限

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

#include <unistd.h>
#include <stdio.h>
int main() {
    int ret = access("a.txt", F_OK);
    if(ret == -1) {
        perror("access");
        return -1;
    }
    printf("文件存在！！!\n");
    return 0;
}

chmod函数的使用：修改文件的权限

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

*/
#include <sys/stat.h>
#include <stdio.h>
int main() {

    int ret = chmod("a.txt", 0777);

    if(ret == -1) {
        perror("chmod");
        return -1;
    }
    return 0;
}

chown函数：

通过vim /etc/passwd可以查看用户ID，通过vim /etc/group可以查看组ID。通过sudo useradd xxx可以新建用户。通过id xxx可以查看xxx的用户ID,组ID。

truncate函数：对文件进行缩减或扩展

/*
    #include <unistd.h>
    #include <sys/types.h>
    int truncate(const char *path, off_t length);
        作用：缩减或者扩展文件的尺寸至指定的大小
        参数：
            - path: 需要修改的文件的路径
            - length: 需要最终文件变成的大小
        返回值：
            成功返回0, 失败返回-1
*/

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

int main() {

    int ret = truncate("b.txt", 5);

    if(ret == -1) {
        perror("truncate");
        return -1;
    }
    return 0;
}

1.7.6 目录操作函数

int mkdir(const char *pathname, mode_t mode);//创建目录
int rmdir(const char *pathname);//删除空目录
int rename(const char *oldpath, const char *newpath);//对目录进行重命名
int chdir(const char *path);//更改当前路径
char *getcwd(char *buf, size_t size);//类似于pwd，获取当前的路径

rm -rf aaa:删除aaa目录，注意只有目录有可执行权限，才能进入目录，否则不能进入目录。

mkdir函数：

/*
    #include <sys/stat.h>
    #include <sys/types.h>
    int mkdir(const char *pathname, mode_t mode);
        作用：创建一个目录
        参数：
            pathname: 创建的目录的路径
            mode: 权限，八进制的数
        返回值：
            成功返回0， 失败返回-1
*/
#include <sys/stat.h>
#include <sys/types.h>
#include <stdio.h>

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

rename函数：

/*
    #include <stdio.h>
    int rename(const char *oldpath, const char *newpath);

*/
#include <stdio.h>
int main() {
    int ret = rename("aaa", "bbb");
    if(ret == -1) {
        perror("rename");
        return -1;
    }
    return 0;
}

chdir函数和*getcwd函数：修改当前的目录，获取当前的路径

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

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

*/
#include <unistd.h>
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
int main() {

    // 获取当前的工作目录
    char buf[128];
    getcwd(buf, sizeof(buf));
    printf("当前的工作目录是：%s\n", buf);

    // 修改工作目录
    int ret = chdir("/home/ygtrece/linux/lesson13");
    if(ret == -1) {
        perror("chdir");
        return -1;
    } 

    // 创建一个新的文件
    int fd = open("chdir.txt", O_CREAT | O_RDWR, 0664);
    if(fd == -1) {
        perror("open");
        return -1;
    }

    close(fd);
    // 获取当前的工作目录
    char buf1[128];
    getcwd(buf1, sizeof(buf1));
    printf("当前的工作目录是：%s\n", buf1);
    return 0;
}

1.7.7 目录遍历函数

DIR *opendir(const char *name);//打开一个目录
struct dirent *readdir(DIR *dirp);//读取目录中的数据
struct dirent{
//此目录进入点的 inode
ino_t d_ino;
//目录文件开头至此目录进入点的位移
off_t d_off;
// d_name的长度 , 不包含 NULL 字符
unsigned short int d_reclen;
// d_name所指的文件类型，d_type又包括DT_BLK块设备,DT_CHR字符设备,DT_DIR目录,DT_LNK软连接,DT_FIFO管道,DT_REG普通文件,DT_SOCK套接字,DT_UNKNOWN未知
unsigned char d_type;
//文件名
char d_name[256];
};
int closedir(DIR *dirp);//关闭目录

一个案例：获取某个路径下的普通文件的个数。

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


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

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

*/
#include <sys/types.h>
#include <dirent.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int getFileNum(const char * path);

// 读取某个目录下所有的普通文件的个数
int main(int argc, char * argv[]) {
    if(argc < 2) {
        printf("%s path\n", argv[0]);
        return -1;
    }

    int num = getFileNum(argv[1]);

    printf("普通文件的个数为：%d\n", num);

    return 0;
}

// 用于获取目录下所有普通文件的个数
int getFileNum(const char * path) {

    // 1.打开目录
    DIR * dir = opendir(path);

    if(dir == NULL) {
        perror("opendir");
        exit(0);
    }
    struct dirent *ptr;
    // 记录普通文件的个数
    int total = 0;

    while((ptr = readdir(dir)) != NULL) {

        // 获取名称
        char * dname = ptr->d_name;

        // 忽略掉. 和..
        if(strcmp(dname, ".") == 0 || strcmp(dname, "..") == 0) {
            continue;
        }

        // 判断是否是普通文件还是目录
        if(ptr->d_type == DT_DIR) {
            // 目录,需要继续读取这个目录
            char newpath[256];
            sprintf(newpath, "%s/%s", path, dname); //得到子目录，比如linux中的linux/lesson02
            total += getFileNum(newpath);
        }

        if(ptr->d_type == DT_REG) {
            // 普通文件
            total++;
        }
    }
    // 关闭目录
    closedir(dir);
    return total;
}

1.7.8 dup和dup2函数

1 2	int dup(int oldfd);//复制文件描述符 int dup2(int oldfd, int newfd);//重定向文件描述符

dup函数的使用

/*
    #include <unistd.h>
    int dup(int oldfd);
        作用：复制一个新的文件描述符
        fd=3, int fd1 = dup(fd),
        fd指向的是a.txt, fd1也是指向a.txt
        从空闲的文件描述符表中找一个最小的，作为新的拷贝的文件描述符,即4


*/

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

int main() {
    int fd = open("a.txt", O_RDWR | O_CREAT, 0664);
    int fd1 = dup(fd);
    if(fd1 == -1) {
        perror("dup");
        return -1;
    }
    printf("fd : %d , fd1 : %d\n", fd, fd1);

    close(fd);

    char * str = "hello,world";
    int ret = write(fd1, str, strlen(str));
    if(ret == -1) {
        perror("write");
        return -1;
    }

    close(fd1);
    return 0;
}

dup2函数：

/*
    #include <unistd.h>
    int dup2(int oldfd, int newfd);
        作用：重定向文件描述符
        oldfd 指向 a.txt, newfd 指向 b.txt
        调用函数成功后：newfd 和 b.txt 做close, newfd 指向了 a.txt
        oldfd 必须是一个有效的文件描述符
        oldfd和newfd值相同，相当于什么都没有做
*/
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
int main() {

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

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

    printf("fd : %d, fd1 : %d\n", fd, fd1);//输出3，4

    int fd2 = dup2(fd, fd1);
    if(fd2 == -1) {
        perror("dup2");
        return -1;
    }

    // 通过fd1去写数据，实际操作的是1.txt，而不是2.txt
    char * str = "hello, dup2";
    int len = write(fd1, str, strlen(str));

    if(len == -1) {
        perror("write");
        return -1;
    }
    printf("fd : %d, fd1 : %d, fd2 : %d\n", fd, fd1, fd2); //输出3，4，4
    close(fd);
    close(fd1);
    return 0;
}

1.7.9 fcntl函数

1 2	//复制文件描述符,设置获取文件的状态标志 int fcntl(int fd, int cmd, ... /* arg */ );

阻塞和非阻塞：描述的是函数调用的行为,阻塞函数指的是当执行到这个函数时进程挂起，得到返回值之后进程再继续执行，非阻塞函数不会影响当前的进程。

当新建一个命令行窗口时，就是阻塞态，命令行也是一个进程。

例子：实现向文件中添加数据。

/*

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

    int fcntl(int fd, int cmd, ...); //...表示可变参数
    参数：
        fd : 表示需要操作的文件描述符
        cmd: 表示对文件描述符进行如何操作
            - F_DUPFD : 复制文件描述符,复制的是第一个参数fd，得到一个新的文件描述符（返回值）
                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 表示追加数据
                NONBLOK 设置成非阻塞
        
        阻塞和非阻塞：描述的是函数调用的行为。
*/

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

int main() {

    // 1.复制文件描述符
    // int fd = open("1.txt", O_RDONLY);
    // int ret = fcntl(fd, F_DUPFD);

    // 2.修改或者获取文件状态flag
    int fd = open("1.txt", O_RDWR);
    if(fd == -1) {
        perror("open");
        return -1;
    }

    // 获取文件描述符状态flag
    int flag = fcntl(fd, F_GETFL);
    if(flag == -1) {
        perror("fcntl");
        return -1;
    }
    flag |= O_APPEND;   // flag = flag | O_APPEND

    // 修改文件描述符状态的flag，给flag加入O_APPEND这个标记
    int ret = fcntl(fd, F_SETFL, flag);
    if(ret == -1) {
        perror("fcntl");
        return -1;
    }

    char * str = "nihao";
    write(fd, str, strlen(str));

    close(fd);

    return 0;
}