1. 创建守护进程

功能：将服务器框架以程序化的方式运行，设置一个守护进程。当负责服务器运行的进程挂了之后能够将其拉回重新运行起来。
框架系统化开发 - 图1

1.2 记录父子进程的进程信息

功能：设置一个结构体专门用于记录服务器进程的启动时间、重启次数等相关信息。并将其置为单例模式来处理。

  1. /**
  2.  * @brief 服务器进程信息结构体
  3.  */
  4. struct ProcessInfo
  5. {
  6.     pid_t       parent_pid;             //父进程PID
  7.     pid_t       main_pid;               //主进程PID
  8.     uint64_t    parent_start_time = 0;  //父进程开启时间
  9.     uint64_t    main_start_time = 0;    //主进程开启时间
  10.     uint32_t    restart_count = 0;      //服务器重启次数
  11. };
  12. //置为单例
  13. typedef Single<ProcessInfo> ProcessInfoMgr;

1.3 接口：start_daemon()函数

功能：负责启动服务器程序，可选择是否以守护进程方式启动。

  1. /**
  2.  * @brief 以守护进程的方式启动程序
  3.  * @param[in] argc 传入参数的个数
  4.  * @param[in] argv 传入参数的数值组
  5.  * @param[in] main_cb 真正运行的函数
  6.  * @param[in] is_daemon 是否以守护进程的方式启动
  7.  * @return 返回程序执行结果
  8.  */
  9. int start_daemon(int argc, char* argv[], 
  10.     std::function<int(int argc, char*argv[])> main_cb, bool is_daemon)
  11. {
  12.     if(!is_daemon)
  13.     {
  14.         return real_start(argc, argv, main_cb);
  15.     }
  17.     return real_daemon(argc, argv, main_cb);
  19. }

  • 两个辅助函数：

    1.3.1 real_daemon()

    功能：开辟守护进程以及崩溃后重启

    1. /**
    2. * @brief 开辟守护进程以及崩溃后重启
    3. * @param[in] argc 传入参数的个数
    4. * @param[in] argv 传入参数的数值组
    5. * @param[in] main_cb 真正运行的函数
    6. * @return 返回程序执行结果 
    7. */
    8. static int real_daemon(int argc, char* argv[], 
    9.   std::function<int(int argc, char* argv[])> main_cb)
    10. {
    11.   //开启守护
    12.   daemon(1, 0);
    13.   //获取当前进程(父进程)PID
    14.   ProcessInfoMgr::GetInstance()->parent_pid = getpid();
    15.   //获取当前进程(父进程)的启动时间
    16.   ProcessInfoMgr::GetInstance()->parent_start_time = GetCurrentMs();
    18.   while(1)
    19.   {
    20.       pid_t pid = fork();
    21.       if(pid == 0)    //子进程
    22.       {
    23.           ProcessInfoMgr::GetInstance()->main_pid = getpid();
    24.           ProcessInfoMgr::GetInstance()->main_pid = GetCurrentMs();
    25.           KIT_LOG_INFO(g_logger) << "process start pid=" << getpid();
    27.           return real_start(argc, argv, main_cb);
    28.       }
    29.       else if(pid > 0)   //当前父进程
    30.       {
    31.           int status = 0;
    32.           waitpid(pid, &status, 0);
    33.           if(status)
    34.           {
    35.               //服务器进程崩溃
    36.               KIT_LOG_ERROR(g_logger) << "child process crash! pid=" << pid << ", status=" << status;
    37.           }
    38.           else
    39.           {   
    40.               //服务器进程正常退出
    41.               KIT_LOG_INFO(g_logger) << "child process finished! pid=" << pid;
    43.               break;
    44.           }
    46.           ProcessInfoMgr::GetInstance()->restart_count += 1;
    47.           //等待资源释放
    48.           sleep(g_daemon_restart_interval->getValue());
    49.       }
    50.       else //出错
    51.       {
    52.           KIT_LOG_ERROR(g_logger) << "fork error ret=" << pid << 
    53.               "errno=" << errno << ",is:" << strerror(errno);
    54.           return -1;
    55.       }  
    56.   }
    58.   return 0;
    59. }

1.3.2 real_start()

功能：执行进程中需要执行的函数操作

  1. /**
  2.  * @brief 执行进程中真正运行函数
  3.  * @param[in] argc 传入参数的个数
  4.  * @param[in] argv 传入参数的数值组
  5.  * @param[in] main_cb 真正运行的函数
  6.  * @return 返回程序执行结果
  7.  */
  8. static int real_start(int argc, char* argv[], 
  9.     std::function<int(int argc, char* argv[])> main_cb)
  10. {
  11.     return main_cb(argc, argv);
  12. }

2. 外部传入参数解析以及环境变量类封装

功能：./kitserver -a -b -c xxx.conf。通过int argc, char* argv[]一些参数配置或者某个路径下配置文件来启动服务器。将key值和val值分离开存储，并对key值作一个补充的描述说明。另外，对程序运行的环境变量做一个管理和封装。

2.1 成员变量

  1. class Env
  2. {
  3.     ...
  5. private:
  6.     //读写锁
  7.     MutexType m_mutex;
  8.     //参数集合
  9.     std::map<std::string, std::string> m_args;
  10.     //对参数的解释说明
  11.     std::vector<std::pair<std::string, std::string> > m_helps;
  12.     //当前运行程序名称
  13.     std::string m_programName;
  14.     //二进制可执行文件的绝对路径
  15.     std::string m_exe;
  16.     //二进制可执行文件的包含文件夹的绝对路径
  17.     std::string m_cwd;
  19. };

2.2 核心接口

2.2.1 init()

功能：对外部传入的参数作解析分离。并且获取当前程序的可执行二进制文件路径的环境变量。

  • 外部参数可能出现的情况：
  1. -key1 val -key2
  2. -key1 -key2 val
  3. -key1 -key2
  4. -key
  • 核心逻辑：

  1. 当前字符串的首字符是"-"字符：表明这一项可能是一个 -key值。进一步判断这一项的字符串长度是否合法，排除只有字符"-"的情况：

    1. 合法，设置一个变量now_key记录上一次轮询中-key值字符的首地址，判断当前该变量是否已经有值：
      1. 有值，代表上一次的-key值还未存储，调用add()加入到集合中
      2. 没有值，代表上一次分离出来的是val值，已经存储过。
    2. 非法，报错返回

  2. 当前字符串的首字符不是"-"字符：表明这一项可能是一个val值，看now_key是否有值：

    1. 有值，说明上一次的-key值是带val值的，它们需要配对加入
    2. 没有值，这是一个非法的参数，不能单独出现val值
  1. /**
  2.  * @brief 解析传入的外部参数以及获取可执行文件的绝对路径
  3.  * @param[in] argc 传入的参数个数
  4.  * @param[in] argv 传入的参数数值组
  5.  * @return 返回解析是否成功
  6.  */
  7. bool Env::init(int argc, char* argv[])
  8. {
  10.     char link[1024] = {0};
  11.     char path[1024] = {0};
  12.     //从环境变量中拼装出所需的可执行文件的符号链接路径
  13.     sprintf(link, "/proc/%d/exe", getpid());
  14.     //通过符号链接路径读取出真正的路径
  15.     if(readlink(link, path, sizeof(path)) < 0)
  16.     {
  17.         KIT_LOG_ERROR(g_logger) << "readlink error, errno=" << errno
  18.             << ",is:" << strerror(errno);
  19.         return false;
  20.     }
  21.     //拿到执行文件的绝对路径 /path/xxx/exe
  22.     m_exe = path;
  24.     //把执行文件的所在文件夹路径截取出来
  25.     auto pos = m_exe.find_last_of("/");
  26.     m_cwd = m_exe.substr(0, pos) + "/";
  29.     m_programName = argv[0];
  31.     //  -config /path/to/config -file xxxxx
  32.     const char* now_key = nullptr;
  34.     //0号位置放的是执行程序名称
  35.     for(int i = 1;i < argc;++i)
  36.     {
  37.         //'-'开头表示是key
  38.         if(argv[i][0] == '-')
  39.         {
  40.             if(strlen(argv[i]) > 1)
  41.             {
  42.                 //当前key是否已经有值了
  43.                 if(now_key)
  44.                 {
  45.                     //加入不带值的参数
  46.                     add(now_key, "");
  47.                 }
  48.                 //具体字符的首地址记录下
  49.                 now_key = argv[i] + 1;
  50.             }
  51.             else
  52.             {
  53.                 KIT_LOG_ERROR(g_logger) << "invalid arg, index=" << i 
  54.                     << ", val=" << argv[i];
  56.                 return false;
  57.             }
  58.         }
  59.         else    //代表是参数的值val
  60.         {
  61.             //配置字符已经记录
  62.             if(now_key)
  63.             {
  64.                 add(now_key, argv[i]);
  65.                 now_key = nullptr;
  66.             }
  67.             else
  68.             {
  69.                 KIT_LOG_ERROR(g_logger) << "invalid arg, index=" << i 
  70.                     << ", val=" << argv[i];
  72.                 return false;
  73.             }
  75.         }
  76.     }
  78.     //当只有一个配置且没有val值 将其加入
  79.     if(now_key)
  80.         add(now_key, "");
  82.     return true;
  84. }

2.2.2 setEnv()/getEnv()

功能：设置/获取当前程序的相关进程环境变量

  1. /**
  2.  * @brief 设置环境变量
  3.  * @param name 环境变量的名称key值
  4.  * @param val 环境变量的值val值
  5.  * @return 返回是否设置成功
  6.  */
  7. bool Env::setEnv(const std::string& name, const std::string& val)
  8. {
  9.     return !setenv(name.c_str(), val.c_str(), 1);
  10. }
  12. /**
  13.  * @brief 获取环境变量
  14.  * @param name 环境变量的名称key值
  15.  * @param default_val 环境变量的值val默认值=""
  16.  * @return 返回环境变量对应val值字符串
  17.  */
  18. std::string Env::getEnv(const std::string& name, const std::string&default_val)
  19. {
  20.     const char* v = getenv(name.c_str());
  21.     return v ? std::string(v) : default_val;
  22. }

3. 完成配置项.yaml文件预加载

功能：根据传入一个包含配置文件的文件夹相对路径/绝对路径预先加载.yaml配置文件，如lgo.yaml、http.yaml、tcp.yaml等等。

应用场景：可以添加一个定时器，周期性检查需要的配置项文件，发生改动就重新加载修改对应的配置项，实现实时加载的一种效果。

3.1 新增接口：LoadFromConfigDir()

功能：在Config类中新增一个接口，通过传入一个包含配置文件的文件夹相对路径/绝对路径以及目标文件后缀.yaml，就能自动的搜集文件夹及其子文件夹下包含所有目标文件的文件名。并且未发生修改的文件不会进行加载收集。

  1. /**
  2.  * @brief 记录配置文件最后的修改时间的容器
  3.  */
  4. static std::map<std::string, uint64_t> s_file2modify_time;
  6. /**
  7.  * @brief 对修改和读取配置文件最后的修改时间的互斥锁
  8.  */
  9. static Mutex s_mutex;
  11. /**
  12.  * @brief 以文件夹为单位加载配置文件
  13.  * @param[in] path 配置文件夹的路径
  14.  */
  15. void Config::LoadFromConfigDir(const std::string& path)
  16. {
  17.     //转换为当前运行路径下的绝对路径
  18.     std::string absolute_path = EnvMgr::GetInstance()->getAbsolutePath(path);
  20.     std::vector<std::string> files;
  21.     //找出后缀为.yaml的所有文件的路径+文件名 收集到vector中
  22.     FSUtil::ListAllFile(files, absolute_path, ".yaml");
  24.     //只有当配置文件真的发生修改才去加载这个文件
  25.     //通过查看文件的最后修改时间实现
  26.     for(auto &x : files)
  27.     {
  28.         //读取文件信息
  29.         struct stat st;
  30.         if(lstat(x.c_str(), &st) < 0)
  31.         {
  32.             KIT_LOG_ERROR(g_logger) << "lstat error, errno" << errno
  33.                 << ", is:" << strerror(errno);
  34.             return;
  35.         }
  37.         //加锁 读取和修改 文件最后修改时间
  38.         {
  39.             Mutex::Lock lock(s_mutex);
  40.             //没有修改过就不进行加载
  41.             if(s_file2modify_time[x] == (uint64_t)st.st_mtim.tv_sec)
  42.                 continue;
  44.             s_file2modify_time[x] = (uint64_t)st.st_mtim.tv_sec;
  45.         }
  47.         try
  48.         {
  49.             //通过YAML的接口加载并解析文件
  50.             YAML::Node root = YAML::LoadFile(x);
  51.             LoadFromYaml(root);
  52.             KIT_LOG_INFO(g_logger) << "load config file from .yaml OK, name=" << x;
  53.         }
  54.         catch(...)
  55.         {
  56.             KIT_LOG_ERROR(g_logger) << "load config file error, name=" << x;
  57.         }
  59.     }
  60. }

4. Application类封装

功能：将服务器框架程序化包装。

4.1 成员变量

  1. class Application
  2. {
  3.     ....
  4. private:
  5.     //传入参数个数
  6.     int m_argc = 0;
  7.     //传入参数数值组
  8.     char **m_argv = nullptr;
  9.     //记录不同类型的服务器
  10.     std::vector<http::HttpServer::ptr> m_servers;
  11.     //程序运行的调度器
  12.     IOManager::ptr m_mainIOManager;
  13.     //当前类指针
  14.     static Application* s_instance;
  16. };

4.2 核心接口

4.2.1 init()

功能：初始化程序相关信息。包括：布置程序启动的参数说明、创建工作目录、创建pid文件等

  1. /**
  2.  * @brief 初始化程序
  3.  * @param[in] argc 传入参数个数
  4.  * @param[in] argv 传入参数数值组
  5.  * @return 返回是否初始化成功
  6.  */
  7. bool Application::init(int argc, char* argv[])
  8. {
  9.     m_argc = argc;
  10.     m_argv = argv;
  12.     //添加启动程序的相关指令说明
  13.     Env* env = EnvMgr::GetInstance();
  14.     env->addHelp("s", "start with the terminal");
  15.     env->addHelp("d", "run as daemon");
  16.     env->addHelp("c", "config file peth, default: ./conf");
  17.     env->addHelp("h", "see help");
  19.     bool is_print_help = false;
  20.     if(!env->init(argc, argv))
  21.         is_print_help = true;
  23.     if(env->has("p"))
  24.         is_print_help = true;
  26.     //获取配置文件的文件夹路径 并且加载
  27.     std::string conf_path = env->getConfigPath();
  28.     KIT_LOG_INFO(g_logger) << "load config path:" << conf_path;
  30.     Config::LoadFromConfigDir(conf_path);
  32.     if(is_print_help)
  33.     {
  34.         env->printHelp();
  35.         return false;
  36.     }
  38.     //判断以什么方式启动程序
  39.     int run_type = 0;
  40.     if(env->has("s"))
  41.         run_type = 1;
  42.     else if(env->has("d"))
  43.         run_type = 2;
  45.     if(run_type == 0)
  46.     {
  47.         env->printHelp();
  48.         return false;
  49.     }
  51.     //拼装pid文件 = 工作路径+文件名称
  52.     std::string pid_file = g_server_work_path->getValue() + "/" + g_server_pid_file->getValue();
  54.     //服务器程序是否已经运行 避免重复打开
  55.     if(FSUtil::IsRunningPidFile(pid_file))
  56.     {
  57.         KIT_LOG_ERROR(g_logger) << "server is running! pid_file=" << pid_file;
  58.         return false;
  59.     }
  61.     //如果提供的工作路径不存在要创建一个
  62.     if(!FSUtil::Mkdir(g_server_work_path->getValue()))
  63.     {
  64.         KIT_LOG_ERROR(g_logger) << "creat work path error:[" << g_server_work_path->getValue() << ", errno=" << errno << ",is:" << strerror(errno);
  66.         return false; 
  67.     }
  69.     //打开pid文件 写入进程PID号
  70.     std::ofstream ofs(pid_file);
  71.     if(!ofs)
  72.     {
  73.         KIT_LOG_ERROR(g_logger) << "open pid file error, file=" << pid_file;
  74.         return false; 
  75.     }
  77.     ofs << getpid();
  79.     return true;
  80. }

4.2.2 run()

功能：开始运行服务器程序。可以选择是否是以守护进程的方式启动

  1. /**
  2.  * @brief 启动程序 可以选择是否是以守护进程的方式启动
  3.  * @return 返回是否启动成功 
  4.  */
  5. bool Application::run()
  6. {
  7.     //看是否是以守护进程的方式启动
  8.     bool is_daemon = EnvMgr::GetInstance()->has("d");
  9.     return start_daemon(m_argc, m_argv, std::bind(&Application::main, this, std::placeholders::_1, std::placeholders::_2), is_daemon);
  11. }

4.2.3 main()

功能：真正执行服务器操作的函数。将当前执行服务器程序的子进程的PID写入pid文件，并使用IO调度器调度一个负责建立监听服务的函数/协程run_couroutine()。

  1. /**
  2.  * @brief 真正执行的main函数
  3.  * @param[in] argc 传入参数个数
  4.  * @param[in] argv 传入参数数值组
  5.  * @return
  6.  */
  7. int Application::main(int argc, char* argv[])
  8. {
  9.     std::string pid_file = g_server_work_path->getValue() + "/" + g_server_pid_file->getValue();
  11.     //打开pid文件 写入进程PID号
  12.     std::ofstream ofs(pid_file);
  13.     if(!ofs)
  14.     {
  15.         KIT_LOG_ERROR(g_logger) << "open pid file error, file=" << pid_file;
  16.         return -1; 
  17.     }
  19.     //需要实际执行服务器代码子进程的PID
  20.     ofs << getpid();
  22.     m_mainIOManager.reset(new IOManager("app", 1));
  23.     m_mainIOManager->schedule(std::bind(&Application::run_coroutine, this));
  24.     m_mainIOManager->stop();
  26.     return 0;
  27. }

4.2.4 run_coroutine()

功能：负责执行某一个函数的协程以供调度。读取加载进来的服务器配置文件，根据配置文件中提供的服务器名称、服务器绑定地址、是否支持长连接、接收消息超时时间等来配置并启动一个服务器。

  1. /**
  2.  * @brief 负责执行函数的协程以供调度
  3.  * @return 
  4.  */
  5. int Application::run_coroutine()
  6. {
  7.     auto server_conf = g_http_servers_conf->getValue();
  8.     for(size_t i = 0;i < server_conf.size();++i)
  9.     {
  10.         KIT_LOG_INFO(g_logger) << "server_conf[" << i << "]:\n" << LexicalCast<HttpServerConf, std::string>()(server_conf[i]);
  12.         std::vector<Address::ptr> address;
  13.         for(auto &x : server_conf[i].address)
  14.         {
  15.             //判断是否是IP类地址
  16.             size_t pos = x.find(":");
  17.             if(pos == std::string::npos)
  18.             {
  19.                 KIT_LOG_ERROR(g_logger) << "invalid IPv4 address=" << x;
  20.                 continue;
  21.             }
  23.             //如果是IP类地址
  24.             auto addr = Address::LookUpAny(x);
  25.             if(addr)
  26.             {
  27.                 address.push_back(addr);
  28.                 continue;
  29.             }
  31.             //通过网卡获取地址
  32.             std::vector<std::pair<Address::ptr, uint32_t> > result;
  33.             if(!Address::GetInertfaceAddresses(result, x.substr(0, pos)))
  34.             {
  35.                 KIT_LOG_ERROR(g_logger) << "invlid address=" << x;
  36.                 continue;
  37.             }
  39.             //将获取到的地址设置端口号
  40.             for(auto &i : result)
  41.             {
  42.                 auto ipaddr = std::dynamic_pointer_cast<IPAddress>(i.first);
  43.                 if(ipaddr)
  44.                     ipaddr->setPort(atoi(x.substr(pos + 1).c_str()));
  46.                 address.push_back(ipaddr);
  47.             }
  48.         }
  50.         //创建HTTP服务器
  51.         http::HttpServer::ptr http_server(new http::HttpServer(server_conf[i].keepalive));
  53.         //为服务器绑定地址端口
  54.         std::vector<Address::ptr> fails;
  55.         if(!http_server->bind(address, fails))
  56.         {
  57.             for(auto& x : fails)
  58.             {
  59.                 KIT_LOG_ERROR(g_logger) << "bind address fail:" << *x;
  60.             }
  62.             _exit(0);
  63.         }
  64.         //启动服务器
  65.         http_server->start();
  66.         //设置服务器名称
  67.         if(server_conf[i].name.size())
  68.             http_server->setName(server_conf[i].name);
  70.         //记录已经启动的服务器
  71.         m_servers[server_conf[i].name].push_back(http_server);
  73.     }
  75.     return 0;
  76. }

C\C++知识点补充复习：daemon()函数

功能：用于希望将当前自身进程与控制终端分离并作为系统守护进程在后台运行的程序。

  1. #include <unistd.h>
  3. int daemon(int nochdir, int noclose);
  • 使用注意项：
  1. 如果 nochdir == 0 ，daemon() 将进程的当前工作目录更改为根目录（”/“）； 否则，当前工作目录保持不变。
  2. 如果 noclose == 0 ，daemon()将标准输入、标准输出和标准错误重定向到/dev/null； 否则，不会对这些文件描述符进行任何更改。

C\C++知识点补充复习：wait族函数

功能：用于等待调用进程的子进程的”状态变化”，并获取有关其状态已更改的子进程的信息。

  • “状态变化”的几种情况：
  1. 子进程终止。注意：执行等待操作将会允许系统释放与子进程相关的资源；未执行等待，终止的子进程将会成为僵尸进程。（类似线程的join()函数，回收线程资源）
  2. 子进程被信号中断
  3. 子进程捕获一个信号并且恢复运行 ```cpp

    include

    include

pid_t wait(int *wstatus);

pid_t waitpid(pid_t pid, int *wstatus, int options);

int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options);

  2. - 注意：对于`waitpid()`函数中传参`pid_t pid`有特殊点：
  3. 1. `< -1` 表示等待进程组 ID 等于 pid 绝对值的任何子进程。
  4. 1. `-1` 表示等待任何子进程。
  5. 1. `0` 表示在调用 `waitpid()` 时等待其进程组 ID 等于调用进程的任何子进程。
  6. 1.  `> 0` 表示等待进程 ID 等于 pid 值的子进程。
  8. <a name="Dg4qb"></a>
  9. # C\C++知识点补充复习：`readlink()`函数
  10. 功能：将符号链接路径名（软链接）的内容放在用户指定的缓冲区中，以供使用。
  11. ```cpp
  12. #include <unistd.h>
  14. ssize_t readlink(const char *pathname, char *buf, size_t bufsiz);
  16. #include <fcntl.h>           /* Definition of AT_* constants */
  17. #include <unistd.h>
  19. ssize_t readlinkat(int dirfd, const char *pathname,
  20.               char *buf, size_t bufsiz);

C\C++知识点补充复习：getenv()/setenv()函数

功能：getenv() 函数搜索环境列表以查找环境变量名称，并返回指向相应值字符串的指针；setenv() 函数将变量 name添加到具有value的环境中

注意：对于setenv()函数，如果name不存在则直接添加；如果已经存在，要考虑是否将其现有的value值覆盖，取决于int overwrite变量，为1则覆盖，为0不发生改变并且返回成功状态。

  1. #include <stdlib.h>
  3. int setenv(const char *name, const char *value, int overwrite);
  5. char *getenv(const char *name);

C\C++知识点补充复习：opendir()函数

功能：打开一个目录名对应的目录流，并返回一个指向目录流的指针。 流位于目录中的第一个条目。

返回值：返回一个指向目录流的指针。 出错时，返回 NULL，并适当设置 errno。

  1. #include <sys/types.h>
  2. #include <dirent.h>
  4. DIR *opendir(const char *name);
  5. DIR *fdopendir(int fd);

C\C++知识点补充复习：readdir()函数

功能：通过一个文件夹路径，获取文件夹下的所有文件。

返回值：成功时，返回一个指向不同结构的指针。 （这个结构可能是静态分配的，不要试图释放它），注意：如果到达目录流的末尾，则返回 NULL并且不更改 errno。 如果发生错误，则返回 NULL 并适当设置 errno。 要区分流的结束和错误，请在调用 readdir() 之前将 errno 设置为零，然后如果返回 NULL，则检查 errno 的值。

  1. #include <dirent.h>
  3. struct dirent *readdir(DIR *dirp);
  5. struct dirent {
  6.    ino_t          d_ino;       /* Inode number */
  7.    off_t          d_off;       /* Not an offset; see below */
  8.    unsigned short d_reclen;    /* Length of this record */
  9.    unsigned char  d_type;      /* Type of file; not supported
  10.                                   by all filesystem types */
  11.    char           d_name[256]; /* Null-terminated filename */
  12. };
  • unsigned char d_type指示文件类型：
    • DT_BLK 这是一个块设备。
    • DT_CHR 这是一个字符设备。
    • DT_DIR 这是一个目录。
    • DT_FIFO 这是一个命名管道（FIFO）。
    • DT_LNK 这是一个符号链接。
    • DT_REG 这是一个常规文件。
    • DT_SOCK 这是一个 UNIX 域套接字。
    • DT_UNKNOWN 无法确定文件类型。

C\C++知识点补充复习：access()函数

功能：检查调用进程是否可以访问文件路径名。如果 pathname 是符号链接，则取消引用。

int mode：F_OK 测试文件是否存在。 R_OK、W_OK 和 X_OK 分别测试文件是否存在并授予读取、写入和执行权限。

返回值：成功时（授予所有请求的权限，或模式为F_OK 且文件存在），返回0。 出错时（mode 中的至少一位请求被拒绝的权限，或者 mode 是 F_OK 并且文件不存在，或者发生了其他错误），返回 -1，并适当地设置 errno。

  1. #include <unistd.h>
  3. int access(const char *pathname, int mode);

C\C++知识点补充复习：lstat()函数

功能：返回文件相关信息，和stat()函数功能类似。如果 pathname是符号链接，则它返回有关链接本身的信息，而不是它所引用的文件。

返回值：成功时，返回0。 出错时，返回 -1，并适当设置 errno。

  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <unistd.h>
  5. int stat(const char *pathname, struct stat *statbuf);
  6. int fstat(int fd, struct stat *statbuf);
  7. int lstat(const char *pathname, struct stat *statbuf);

C\C++知识点补充复习：mkdir()函数

功能：尝试创建一个名为pathname的目录。

返回值：成功时返回零，如果发生错误则返回 -1（在这种情况下，errno 设置得当）

  1. #include <sys/stat.h>
  2. #include <sys/types.h>
  4. int mkdir(const char *pathname, mode_t mode);

mode_t mode：默认是0777全局访问权限

  1. The following mask values are defined for the file mode component of the st_mode field:
  3.            S_ISUID     04000   set-user-ID bit (see execve(2))
  4.            S_ISGID     02000   set-group-ID bit (see below)
  5.            S_ISVTX     01000   sticky bit (see below)
  7.            S_IRWXU     00700   owner has read, write, and execute permission
  8.            S_IRUSR     00400   owner has read permission
  9.            S_IWUSR     00200   owner has write permission
  10.            S_IXUSR     00100   owner has execute permission
  12.            S_IRWXG     00070   group has read, write, and execute permission
  13.            S_IRGRP     00040   group has read permission
  14.            S_IWGRP     00020   group has write permission
  15.            S_IXGRP     00010   group has execute permission
  17.            S_IRWXO     00007   others (not in group) have read, write, and ex‐
  18.                                ecute permission
  19.            S_IROTH     00004   others have read permission
  20.            S_IWOTH     00002   others have write permission
  21.            S_IXOTH     00001   others have execute permission

C\C++知识点补充复习：strdup()函数

功能：返回一个指向新字符串的指针，该字符串是const char* s 的副本。 新字符串的内存使用 malloc() 获得，并且可以使用 free() 释放。

返回值：成功时，返回一个指向复制字符串的指针。 如果可用内存不足，则返回 NULL，并设置 errno 以指示错误的原因。

  1. #include <string.h>
  3. char *strdup(const char *s);
  5. char *strndup(const char *s, size_t n);
  6. char *strdupa(const char *s);
  7. char *strndupa(const char *s, size_t n);

C\C++知识点补充复习：strchr()/strrchr()函数

功能：strchr()函数返回一个指针，指向字符串 s中字符 c 的第一次出现。
strrchr()函数返回一个指针，指向字符串 s中字符 c 的最后一次出现。

返回值：返回一个指向匹配字符的指针，如果找不到该字符，则返回 NULL。
注意：终止的空字节被认为是字符串的一部分，因此如果c 被指定为 ‘\0’，这些函数将返回一个指向终止符的指针。

  1. #include <string.h>
  3. char *strchr(const char *s, int c);
  5. char *strrchr(const char *s, int c);