概念：API HOOK顾名思义是，”钩住”函数接口，拦截、控制某一些API函数的调用。用于改造、改变、隐藏（木马病毒正是使用的这一种手段）API执行结果的一种技术。

注意：这里的所说的API HOOK和windows下的 Messages HOOK完全不同。
API HOOK 是拦截目标程序中调用的函数，替换或者修改调用函数的功能。
Messages HOOK是截获程序中的消息或事件

  • 按照实现原理分：API HOOK 和 Messages HOOK
  • 按照作用范围分：全局HOOK 和 局部HOOK
  • 按照权限分：系统内核HOOK 和 用户态HOOK 分别作用在Ring 0 Ring 3
  • 按照实现方式：内联HOOK（inline HOOK） 和 导入表HOOK（IAT HOOK）
  1. 内联HOOK（inline HOOK）(本次开发中使用)

程序在编译链接后成了二进制代码，我们可以找到需要Hook的函数的地址，然后把这个函数在内存中的二进制代码改为一个JMP指令，令其跳转到执行我们自己构造的函数。函数一般都存在于DLL中，当DLL中某个函数被调用后，其所在的DLL将会被映射到进程地址空间中。我们可以通过DLL这个模块找到我们需要Hook的函数的地址。然后在内存中改变其地址，使跳转到我们制定的位置。
（简而言之，内联HOOK的代码段是在运行起来之后，实施的代码段的动态替换）

  1. 导入表HOOK（IAT HOOK）

这种Hook技术是通过分析目标程序PE结构，替换目标API在IAT中的地址为钩子函数的地址来实现。
IAT表大致了解：可执行文件中使用其他 DLL 可执行文件的代码或数据，称为导入或者输入，当 PE 文件载入内存时，加载器会定位所有导入的函数或数据将定位到的内容填写至可执行文件的某个位置供其使用，而这个操作是需要借助导入表来完成的。

导入表中存放了程序所有使用的 DLL 模块名称及导入的函数名称或函数序号。

参考资料：https://blog.csdn.net/junbopengpeng/article/details/28142669?ops_request_misc=&request_id=&biz_id=102&utm_term=hook&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-8-28142669.first_rank_v2_pc_rank_v29&spm=1018.2226.3001.4187

HOOK开发 - 图1

HOOK开发 - 图2

准备：提供两个接口控制当前线程的HOOK状态

  • bool IsHookEnable()：

    1. //当前线程是否被hook
    2. bool IsHookEnable()
    3. {
    4.   return t_hook_enable;
    5. }

  • void SetHookEnable(bool flag)

    1. //设置当前线程的hook状态
    2. void SetHookEnable(bool flag)
    3. {
    4.   t_hook_enable = flag;
    5. }

准备：完成HOOK的初始化

HOOK工作需要在程序真正开始执行前完成，即：在进入main()之前执行完毕。

  1. namespace kit_server
  2. {
  4. static thread_local bool t_hook_enable = false;
  8.  //小技巧，宏定义传参方便初始化
  9. /*等价于
  10.     sleep_f = (sleep_func)dlsym(RTLD_NEXT, sleep);
  11.     usleep_f = (usleep_func)dlsym(RTLD_NEXT, sleep);
  12. */
  14. #define HOOK_FUNC(XX) \
  15.     XX(sleep)\
  16.     XX(usleep)
  20. void hook_init()
  21. {
  22.     static bool is_inited = false;
  24.     if(is_inited)
  25.         return;
  27. #define XX(name)    name ## _f = (name ## _func)dlsym(RTLD_NEXT, #name);
  28.     HOOK_FUNC(XX)
  29. #undef XX
  32. }
  34.     ...
  35.     ...
  37. }
  40. /*----------------------------------------------------------*/
  42. extern "C"
  43. {
  45. #define XX(name) name ## _func name ## _f = nullptr;
  46.     HOOK_FUNC(XX)
  47. #undef XX
  48. /*    等价于
  49.     sleep_func sleep_f = nullpt;
  50.     usleep_func usleep_f = nullpt;
  51. */
  53. }
  55. typedef unsigned int (*sleep_func)(unsigned int secends);
  56. extern sleep_func sleep_f;
  58. typedef int (*usleep_func)(useconds_t usec);
  59. extern usleep_func usleep_f;

方法一：利用C++特性，构造结构体变量，声明为static，利用其结构体的构造函数执行HOOK初始化

  1. //在main() 函数之前执行hook初始化
  2. struct _HookIniter
  3. {
  4.     _HookIniter()
  5.     {
  6.         hook_init();
  7.     }
  8. };
  10. static struct _HookIniter _hook_initer;

方法二：利用C特性，使用__attribute__((constructor))声明，将一个函数置在main()之前执行

  1. void hook_init() __attribute__((constructor));
  3. void hook_init()
  4. {
  5.     static bool is_inited = false;
  7.     if(is_inited)
  8.         return;
  10. #define XX(name)    name ## _f = (name ## _func)dlsym(RTLD_NEXT, #name);
  11.     HOOK_FUNC(XX)
  12. #undef XX
  13. }

辅助类：文件句柄类FdCtx/文件句柄管理类FdManager

目的：在用户态记录文件句柄相关的状态/信息，方便HOOK操作时候，获取对应文件句柄，也能减少系统调用对文件句柄的检查。

· 类关系

HOOK开发 - 图3

1. FdCtx类

1.1 成员变量

  2. /**
  3.  * @brief 文件句柄类
  4.  * @details 管理文件句柄的类型、阻塞状态、关闭状态、读/写超时时间
  5.  */
  6. class FdCtx: public std::enable_shared_from_this<FdCtx>
  7. {
  8.     ...
  9.     ...
  10. private:
  11.     /*采用位域 来记录文件句柄上的一些状态*/
  12.     /// 是否初始化
  13.     bool m_isInit: 1;
  14.     /// 是否是套接字socket类型
  15.     bool m_isSocket: 1;
  16.     /// 是否是用户主动设置为非阻塞
  17.     bool m_userNonblock: 1;
  18.     /// 是否hook非阻塞
  19.     bool m_sysNonblock: 1;
  20.     /// 是否关闭
  21.     bool m_isClosed: 1;
  22.     /// 文件句柄
  23.     int m_fd;
  24.     /// 读超时时间
  25.     uint64_t m_recvTimeout = 0;
  26.     /// 写超时时间
  27.     uint64_t m_sendTimeout = 0;
  29. };

1.2 接口

1.2.1 构造函数

  1. /**
  2.  * @brief 文件句柄类构造函数
  3.  * @param[in] fd 传入fd文件句柄 
  4.  */
  5. FdCtx(int fd);
  7. FdCtx::FdCtx(int fd)
  8.     :m_isInit(false),
  9.      m_isSocket(false),
  10.      m_userNonblock(false),
  11.      m_sysNonblock(false),
  12.      m_isClosed(false),
  13.      m_fd(fd),
  14.      m_recvTimeout(-1),
  15.      m_sendTimeout(-1)
  16. {
  17.     init();
  18. }

1.2.1 init()（私有）（核心）

功能：文件句柄初始化，如果为socket套接字句柄fd要将其置为非阻塞。

  1. /**
  2.  * @brief 文件句柄初始化，如果为socket套接字句柄fd置为非阻塞
  3.  * @return true 初始化成功
  4.  * @return false 初始化失败
  5.  */
  6. bool init();
  7. bool FdCtx::init()
  8. {
  9.     //句柄初始化过了 就返回
  10.     if(m_isInit)
  11.         return true;
  13.     //struct stat 获取当前系统文件句柄的状态
  14.     struct stat fd_stat;
  15.     if(fstat(m_fd, &fd_stat) < 0)
  16.     {
  17.         m_isInit = false;
  18.         m_isSocket = false;
  19.         KIT_LOG_ERROR(g_logger) << "FdCtx init(): fstat() error";
  21.     }
  22.     else
  23.     {
  24.         m_isInit = true;
  25.         //取出状态位 判断句柄类型
  26.         m_isSocket = S_ISSOCK(fd_stat.st_mode);
  27.     }
  29.     //如果是socket 句柄 设置为非阻塞
  30.     if(m_isSocket)
  31.     {
  32.         int flags = fcntl_f(m_fd, F_GETFL, 0);
  33.         //如果句柄阻塞 要设置为非阻塞
  34.         if(!(flags & O_NONBLOCK))
  35.         {
  36.             fcntl_f(m_fd, F_SETFL, flags | O_NONBLOCK);
  37.         }
  39.         m_sysNonblock = true;
  40.     }
  41.     else
  42.     {
  43.         m_sysNonblock = false;
  44.     }
  46.     m_userNonblock = false;
  47.     m_isClosed = false;
  49.     return m_isInit;
  51. }

1.2.2 setTimeout()/getTimeout() （核心）

功能：设置/获取文件句柄上的超时时间，分为读（SO_REVTIMEO）/写（SO_SNDTIMEO）超时类型。

  1. /**
  2.  * @brief 设置IO超时时间
  3.  * @param[in] type 读(SO_REVTIMEO)/写(SO_SNDTIMEO)超时类型
  4.  * @param[in] time 超时时间，单位ms
  5.  */
  6. void setTimeout(int type, uint64_t time);
  7. void FdCtx::setTimeout(int type, uint64_t time)
  8. {
  9.     if(type == SO_RCVTIMEO)
  10.         m_recvTimeout = time;
  11.     else 
  12.         m_sendTimeout = time;
  13. }
  15. /**
  16.  * @brief 获取IO超时时间
  17.  * @param[in] type 读(SO_REVTIMEO)/写(SO_SNDTIMEO)超时类型
  18.  * @return uint64_t 
  19.  */
  20. uint64_t getTimeout(int type);
  21. uint64_t FdCtx::getTimeout(int type)
  22. {
  23.     if(type == SO_RCVTIMEO)
  24.         return m_recvTimeout;
  25.     else 
  26.         return m_sendTimeout;
  27. }

1.2.3 其他常用接口

  1. /**
  2.  * @brief 文件句柄是否已经初始化
  3.  * @return true 已经初始化
  4.  * @return false 没有初始化
  5.  */
  6. bool isInit() const {return m_isInit;}
  8. /**
  9.  * @brief 文件句柄是否是套接字socket类型
  10.  * @return true 是socket
  11.  * @return false 不是socket
  12.  */
  13. bool isSocket() const {return m_isSocket;}
  15. /**
  16.  * @brief 文件句柄是否已经关闭
  17.  * @return true 已经关闭
  18.  * @return false 没有关闭
  19.  */
  20. bool isClose() const {return m_isClosed;}
  22. //设定用户级 非阻塞状态
  23. /**
  24.  * @brief 设定是否是用户设置非阻塞状态
  25.  * @param[in] flag 
  26.  */
  27. void setUserNonblock(bool flag) {m_userNonblock = flag;}
  29. /**
  30.  * @brief 获取是否是用户设置非阻塞状态
  31.  * @return true 是
  32.  * @return false 不是
  33.  */
  34. bool getUserNonblock() const {return m_userNonblock;}
  36. /**
  37.  * @brief 设置系统级 非阻塞状态
  38.  * @param[in] flag 
  39.  */
  40. void setSysNonblock(bool flag) {m_sysNonblock = flag;}
  42. /**
  43.  * @brief 获取系统级 非阻塞状态
  44.  * @return true 是
  45.  * @return false 不是
  46.  */
  47. bool getSysNonblock() const {return m_sysNonblock;}
  49. /**
  50.  * @brief 获取文件句柄
  51.  * @return int 
  52.  */
  53. int getFd() const {return m_fd;}

2. FdManager类

功能：获取/设置fd属性的操作属于”读多写少”的场景，使用读写锁管理文件句柄的队列。并且将该类置为单例模式。

2.1 成员变量

  1. /**
  2.  * @brief 文件句柄管理类
  3.  */
  4. class FdManager
  5. {
  6.     ...
  7.     ...
  8. private:
  9.     /// 读写锁
  10.     MutexType m_mutex;
  11.     /// 文件句柄对象队列
  12.     std::vector<FdCtx::ptr> m_fds;
  14. };
  15. //置为单例
  16. typedef Single<FdManager> FdMgr;

2.2 接口

2.2.1 构造函数

  1. /**
  2.  * @brief 文件句柄管理类构造函数
  3.  */
  4. FdManager();
  6. FdManager::FdManager()
  7. {
  8.     m_fds.resize(64);
  9. }

2.2.2 get() （核心）

功能：获取文件句柄对象，如果文件句柄对象不存在可以选择创建

  1. /**
  2.  * @brief 获取文件句柄对象
  3.  * @param[in] fd 文件句柄 
  4.  * @param[in] auto_create 是否自动创建文件句柄对象 
  5.  * @return FdCtx::ptr 
  6.  */
  7. FdCtx::ptr get(int fd, bool auto_create = false);
  9. FdCtx::ptr FdManager::get(int fd, bool auto_create)
  10. {
  11.     if(fd == -1)
  12.         return nullptr;
  14.     //加读锁
  15.     MutexType::ReadLock lock(m_mutex);
  18.     //如果fd越界说明容量不够 
  19.     if((int)m_fds.size() <= fd)
  20.     {
  21.         //不需要创建
  22.         if(!auto_create)
  23.             return nullptr;
  25.     }
  26.     else    //fd没有越界
  27.     {
  28.         if(m_fds[fd] || !auto_create)
  29.             return m_fds[fd];
  31.     }
  32.     lock.unlock();
  34.     //加写锁
  35.     MutexType::WriteLock lock2(m_mutex);
  36.     FdCtx::ptr ctx(new FdCtx(fd));
  37.     if(fd >= (int)m_fds.size())
  38.         m_fds.resize(fd * 1.5);
  40.     m_fds[fd] = ctx;
  41.     return ctx;
  43. }

2.2.3 del()

功能：删除文件句柄对象

  1. /**
  2.  * @brief 删除文件句柄对象
  3.  * @param fd 
  4.  */
  5. void del(int fd);
  7. void FdManager::del(int fd)
  8. {
  9.     MutexType::WriteLock lock(m_mutex);
  11.     if((int)m_fds.size() <= fd)
  12.         return;
  14.     KIT_LOG_DEBUG(g_logger) << "移除当前fd = " << fd;
  15.     m_fds[fd].reset();
  17. }

1. HOOKsleep、usleep、nanosleep系统函数

功能：使用我们自定义的休眠函数，替换系统调用。
在作用域extern "C"中加入对应的休眠函数的实现，防止C++重载特性破坏。

小难点：bind()函数绑定模板类函数，需要将传入的参数类型显式指定，并且默认参数值也需要显示指定

  • **sleep()**函数： ```cpp extern “C” {

    … …

unsigned int sleep(unsigned int secends) { //如果当前线程没有被hook就返回旧的系统调用执行 if(!kit_server::t_hook_enable) return sleep_f(secends);

  1. kit_server::Coroutine::ptr cor = kit_server::Coroutine::GetThis();
  2. kit_server::IOManager* iom = kit_server::IOManager::GetThis();
  4. //bind 模板函数时候 需要把对应的参数类型设定好 默认参数也需要显示指定
  5. iom->addTimer(secends * 1000, std::bind((void(kit_server::Scheduler::*)(kit_server::Coroutine::ptr, int))&kit_server::IOManager::schedule, iom, cor, -1));
  7. // iom->addTimer(secends * 1000, [iom, cor](){
  8. //     iom->schedule(cor);
  9. // });
  11. kit_server::Coroutine::YieldToHold();
  13. return 0;

}

  2. - `**usleep()**`**函数：**
  3. ```cpp
  4. extern "C"
  5. {
  7.     ...
  8.     ...
  10. int usleep(useconds_t usec)
  11. {
  12.     //如果当前线程没有被hook就返回旧的系统调用执行
  13.     if(!kit_server::t_hook_enable)
  14.         return usleep_f(usec);
  16.     kit_server::Coroutine::ptr cor = kit_server::Coroutine::GetThis();
  17.     kit_server::IOManager* iom = kit_server::IOManager::GetThis();
  19.     iom->addTimer(usec / 1000, std::bind((void(kit_server::Scheduler::*)(kit_server::Coroutine::ptr, int))&kit_server::IOManager::schedule, iom, cor, -1));
  21.     // iom->addTimer(usec / 1000, [iom, cor](){
  22.     //     iom->schedule(cor);
  23.     // });
  25.     kit_server::Coroutine::YieldToHold();
  27.     return 0;
  28. }
  • **nanosleep()**: ```cpp int nanosleep(const struct timespec req, struct timespec rem) { if(!kit_server::t_hook_enable)
    1.   return nanosleep_f(req, rem);
  1. kit_server::Coroutine::ptr cor = kit_server::Coroutine::GetThis();
  2. kit_server::IOManager* iom = kit_server::IOManager::GetThis();
  4. uint64_t ms = 0;
  5. if(errno == EINTR)
  6. {
  7.     if(rem != nullptr)
  8.         ms = rem->tv_sec * 1000 + rem->tv_nsec / 1000 / 1000; 
  9. }
  10. else 
  11.     ms = req->tv_sec * 1000 + req->tv_nsec / 1000 / 1000;
  13. iom->addTimer(ms, std::bind((void(kit_server::Scheduler::*)(kit_server::Coroutine::ptr, int))&kit_server::IOManager::schedule, iom, cor, -1));
  15. // iom->addTimer(ms, [iom, cor](){
  16. //     iom->schedule(cor);
  17. // });
  19. kit_server::Coroutine::YieldToHold();
  21. return 0;

}

  2. <a name="OJpmd"></a>
  3. # 2. HOOK socket  API
  4. 目的：通过截取系统事件对应的系统调用函数，在其函数中重新自定义我们所需要的一些操作。结合本使用案例，就是需要完成`socket`原有API的功能基础上，配合`class:FdCtx`套接字状态类以及`class:FdManager`套接字管理类，能够在用户态层面管理套接字的相关属性、信息。
  6. <a name="pDLWO"></a>
  7. ## 2.1 核心模板函数：`do_io`
  8. 功能：复用HOOK IO时候重复的一些代码功能。尤其对于读写IO，执行的操作基本是一样的。对于一些特定的IO就写特定的功能即可。
  9. ```cpp
  10. template<class OriginFunc, typename... Args>
  11. static ssize_t do_io(int fd, OriginFunc func, const char *hook_func_name, 
  12.     uint32_t event, int timeout_so, Args&&... args)
  • 核心逻辑：

  1. 从FdManager中通过get()获取当前文件描述符fd的对象FdCtx

    1. FdManger不存在当前的文件描述符fd，我们认为它不是一个socket，执行原来的系统调用
    2. 该描述符是socket但是已经被关闭，就返回错误
    3. 该描述符明确不是socket 或者 已经被设置为NonBlock非阻塞状态，执行原来的系统调用

  2. 获取当前套接字上的读/写超时时间getTimeout()，并且通过shared_ptr<>设置一个定时器的条件（结构体struct timer_info）用于判定定时器是否是超时被执行。

**RETRY:**

  1. 对读写IO执行一次IO操作。ssize_t n = func(fd, std::forward<Args>(args)...);

    1. 判断返回值是否出错，是否属于被中断errno = EINTR。如果是，需要对重试IO操作
    2. 判断返回值是否出错，是否属于阻塞状态errno = EAGAIN。如果是：
      1. 添加一个条件定时器ConditionTimer，将 2. 中的设置的条件赋值给弱指针weak_ptr<>管理。定时器到时后，取消对应fd上的事件并且强制触发回调函数。
      2. IOManagerIO调度器为fd添加所需的读/写事件，设置异步回调
      3. 将当前协程挂起让出执行权Coroutine::YieldToHold()

  2. 等待协程切回（从Coroutine::YieldToHold()返回），读事件READ返回继续执行read；写事件WRITE返回继续执行write。

  • 切回的条件：
    1. IO没有数据到达，条件定时器超时强制唤醒：

取消全部套接字全部事件cancelEvent()，没有指定回调函数function<> cb，主动触发事件triggerEvent()默认将当前的协程作为任务加入队列，执行上一次没执行完的协程内容。

  1. 定时器还没有超时，IO活跃有数据到达触发回调

根据epoll_wait()带回的活跃IO信息epoll_event拿到对应的套接字对象FdCtx，主动触发事件triggerEvent()默认将当前的协程作为任务加入队列，执行上一次没执行完的协程内容。

  1. 检查之前的条件定时器是否还存在，存在就要将其取消，否则还会超时触发
  2. 检查超时条件是否有值，有值说明还没释放，返回错误
  3. goto RETRY继续IO操作，读写数据

2.2 需要HOOK的一些API

2.2.1 读/写相关API

统一使用do_io()函数处理，因为这些API几乎都是容易阻塞的，而阻塞就需要HOOK来和协程结合，达到同步编程异步效率的效果。

  • read/write
  • readv/writev
  • recv/send
  • recvfrom/sendto
  • recvmsg/sendmsg

2.2.2 socket相关API

这类接口比较特殊，需要单独处理，不能使用do_io()来概括。

2.2.2.1 socket()

功能：创建套接字的同时，需要把系统返回的fd通过FdManager在用户态维护在FdCtx中。

  1. int socket(int domain, int type, int protocol)
  2. {
  3.     if(!kit_server::t_hook_enable)
  4.         return socket_f(domain, type, protocol);
  6.     KIT_LOG_DEBUG(g_logger) << "hook socket start";
  7.     int fd = socket_f(domain, type, protocol);
  8.     if(fd < 0)
  9.         return fd;
  11.     //由FdManager创建一个fd
  12.     kit_server::FdMgr::GetInstance()->get(fd, true);
  14.     return fd;
  16. }

2.2.2.2 accept()

功能：接受客户端连接返回通信套接字，要把系统返回的fd通过FdManager在用户态维护在FdCtx中。

由于accept本身是必然的会阻塞的，因此可以使用do_io()来HOOK它，和socket()类似

  1. int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
  2. {
  3.     int fd = do_io(sockfd, accept_f, "accept", kit_server::IOManager::Event::READ, 
  4.         SO_RCVTIMEO, addr, addrlen);
  6.     if(fd >= 0)
  7.     {
  8.         //把新建立的通信套接字加入到FdManager中去管理
  9.         kit_server::FdMgr::GetInstance()->get(fd, true);
  10.     }
  12.     return fd;
  13. }

2.2.2.3 close()

功能：关闭文件描述符，要使用系统调用的之前，需要检查对应的fd是否存在于FdManager中，存在需要先将其删除，在关闭。

  1. int close(int fd)
  2. {
  3.     if(!kit_server::t_hook_enable)
  4.         return close_f(fd);
  7.     KIT_LOG_DEBUG(g_logger) << "hook close start";
  9.     kit_server::FdCtx::ptr ctx = kit_server::FdMgr::GetInstance()->get(fd);
  12.     //如果是socket 
  13.     if(ctx)
  14.     {
  15.         KIT_LOG_DEBUG(g_logger) << "get ctx fd=" << ctx->getFd();
  16.         auto iom = kit_server::IOManager::GetThis();
  17.         if(iom)
  18.         {
  19.             iom->cancelAll(fd);
  20.         }
  22.         kit_server::FdMgr::GetInstance()->del(fd);
  23.     }
  25.     return close_f(fd);
  26. }

2.2.2.4 connect()/connect_with_timeout()（重点）

功能：连接服务器，原本的系统调用不具备手动设置超时的功能，导致默认的超时设置时间太长，不同环境下时长不同，在75s到几分钟之间；而且远端服务器不存在或者未开启将一直处于阻塞（套接字为阻塞状态时）

冷门易错点①：通过man查看Linux手册，connect返回的错误码中有一个是EINPROGRESS，对应的描述大致是：在非阻塞模式下，如果连接不能马上建立成功就会返回该错误码。返回该错误码，可以通过使用select或者poll来查看套接字是否可写，如果可写，再调用getsockopt来获取套接字层的错误码errno来确定连接是否真的建立成功，如果getsockopt返回的错误码是0则表示连接真的建立成功，否则返回对应失败的错误码。

冷门易错点②：针对select/poll/epoll监测管理的IO上的可读/可写事件，有两条规则：

  1. 当连接建立成功时，套接口描述符变成可写（连接建立时，写缓冲区空闲，所以可写）
  2. 当连接建立出错时，套接口描述符变成既可读又可写（由于有未决的错误，从而可读又可写）

[

](https://blog.csdn.net/li_qinging/article/details/102574446)

实现connect()的超时设置有如下思路：

  1. 利用**select()/poll()**检测**socket**。

    1. 创建一个socket
    2. 将套接字设置为NonBlock非阻塞状态
    3. 执行connect()之后，利用select检测该套接字上的是否可写，来判断connect()的结果
    4. select()返回后还要进一步判断，getsockopt()检测连接是否有问题。有问题返回错误
    5. 没有问题返回0，将socket重新设置为非阻塞的

  2. 本例利用条件定时器ConditionTimer，配合配置系统设定一个**connect_with_timeout**的超时时间

    1. 当系统调用connect()没马上建立连接时：返回的是EINPROGRESS，利用ConditionTimer条件定时器，超时（默认5000ms）触发强行唤醒协程执行

    2. connect()成功时，epoll管理的IO会触发WRITE写事件；connect仍然存在异常时，epoll管理的IO会同时触发READ/WRITE可读可写事件，触发异步回调唤醒协程执行。协程切回后使用getsockopt()进一步判断连接是否真的成功建立

  3. **connect()**返回错误码中还有一个是**EISCONN**，表示连接已经建立。

我们可以再一次调用connect()函数，如果返回的错误码是EISCONN，则表示连接建立成功，否则认为连接建立失败。

  1. //带超时功能的connect
  2. int connect_with_timeout(int sockfd, const struct sockaddr *addr, socklen_t addrlen, uint64_t timeout_ms)
  3. {
  4.     if(!kit_server::t_hook_enable)
  5.         return connect_f(sockfd, addr, addrlen);
  7.     KIT_LOG_DEBUG(g_logger) << "hook connect start";
  9.     kit_server::FdCtx::ptr ctx = kit_server::FdMgr::GetInstance()->get(sockfd);
  10.     if(!ctx || ctx->isClose())
  11.     {
  12.         errno = EBADF;
  13.         return -1;
  14.     }
  16.     if(!ctx->isSocket())
  17.         return connect_f(sockfd, addr, addrlen);
  19.     if(ctx->getUserNonblock())
  20.         return connect_f(sockfd, addr, addrlen);
  23.     //创建socket时候已经设置为 非阻塞的 因此这里不会阻塞
  24.     int n = connect_f(sockfd, addr, addrlen);
  25.     if(n == 0)
  26.     {
  27.         return 0;
  28.     }
  29.     else if(n != -1 || errno != EINPROGRESS)
  30.     {
  31.         return n;
  32.     }
  34.     kit_server::IOManager* iom = kit_server::IOManager::GetThis();
  35.     kit_server::Timer::ptr timer;
  36.     std::shared_ptr<kit_server::timer_info> tinfo(new kit_server::timer_info);
  37.     std::weak_ptr<kit_server::timer_info> winfo(tinfo);
  39.     if(timeout_ms != (uint64_t)-1)
  40.     {
  42.         timer = iom->addConditionTimer(timeout_ms, [iom, winfo, sockfd](){
  43.             auto t = winfo.lock();
  44.             if(!t || t->canceled)
  45.                 return;
  47.             t->canceled = ETIMEDOUT;
  48.             iom->cancelEvent(sockfd, kit_server::IOManager::Event::WRITE);
  50.         }, winfo);
  51.     }
  53.     //添加写事件是因为 connect成功后马上可写
  54.     int ret = iom->addEvent(sockfd, kit_server::IOManager::Event::WRITE);
  55.     if(ret == 0)    //如果添加写事件成功
  56.     {
  57.         //切出
  58.         kit_server::Coroutine::YieldToHold();
  60.         //切回
  61.         if(timer)
  62.             timer->cancel();
  64.         if(tinfo->canceled)
  65.         {
  66.             errno = tinfo->canceled;
  67.             return -1;
  68.         }
  69.     }
  70.     else
  71.     {
  72.         if(timer)
  73.             timer->cancel();
  75.         KIT_LOG_ERROR(g_logger) << "connect: addEvent(" << sockfd << ", WRITE) error=" << errno << "is:" << strerror(errno); 
  76.     }
  78.     //协程切回后 检查一下socket上是否有错误  才能最终判断连接是否建立
  79.     int m_error = 0;
  80.     socklen_t len = sizeof(int);
  82.     if(getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &m_error, &len) < 0)
  83.     {
  84.         KIT_LOG_ERROR(g_logger) << "connect with timeout getsockopt error";
  85.         return -1;
  86.     }
  88.     //检测sockfd 上是否有错误发生 有就通过int error变量带回
  89.     //没有错误才是真的建立连接成功
  90.     if(!m_error)
  91.         return 0;
  92.     else 
  93.     {
  94.         errno = m_error;
  95.         return -1;
  96.     }
  98. }
  101. //connect  较为复杂！
  102. int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
  103. {
  104.     return connect_with_timeout(sockfd, addr, addrlen, kit_server::s_connect_timeout);
  105. }

2.2.2.5 fcntl()

功能：设置/获取系统fd上的相关状态。同时还要将状态同步到用户态的FdCtx上

小技巧：HOOK fcntl()需要把它内部所有标志位都罗列重写，否则导致部分功能不可用。通过man查看Linux手册，按照传参类型进行一个分类，重点实现与我们代码模块相关的标志位，忽略其他无关的标志位，复用减少代码量，按int、void、锁相关struct flock*、进程组相关struct f_owner_ex *进行分类

  • 重点实现：
  1. **F_SETFL**设置文件状态

该标志位为int，通过可变参数传递，设置当前用户态FdCtx的信息，并设置系统中fd的状态是否是非阻塞的O_NONBLOCK

  1. **F_GETFL**获取文件状态

该标志位为void，直接调用系统调用，根据传回的结果，又将用户态FdCtx对象的信息更新即可

  1. //fcntl  用户级nonblock
  2. int fcntl(int fd, int cmd, ... /* arg */ )
  3. {
  4.     va_list va;
  5.     va_start(va, cmd);
  6.     switch (cmd)
  7.     {
  8.     //设置文件状态
  9.     case F_SETFL:
  10.     {
  11.         int arg = va_arg(va, int);
  12.         va_end(va);
  14.         kit_server::FdCtx::ptr ctx = kit_server::FdMgr::GetInstance()->get(fd);
  15.         if(!ctx || ctx->isClose() || !ctx->isSocket())
  16.             return fcntl_f(fd, cmd, arg);
  18.         ctx->setUserNonblock(arg & O_NONBLOCK);
  20.         if(ctx->getSysNonblock())
  21.         {
  22.             arg |= O_NONBLOCK;
  23.         }
  24.         else
  25.         {
  26.             arg &= ~O_NONBLOCK;
  27.         }
  29.         return fcntl_f(fd, cmd, arg);
  30.     }
  31.     break;
  33.     //获取文件状态
  34.     case F_GETFL:
  35.     {
  36.         va_end(va);
  37.         int arg = fcntl_f(fd, cmd);
  38.         kit_server::FdCtx::ptr ctx = kit_server::FdMgr::GetInstance()->get(fd);
  39.         if(!ctx || ctx->isClose() || !ctx->isSocket())
  40.             return arg;
  42.         if(ctx->getUserNonblock())
  43.         {
  44.             arg |= O_NONBLOCK;
  45.         }
  46.         else
  47.         {
  48.             arg &= ~O_NONBLOCK;
  49.         }
  51.         return arg;
  53.     }
  54.     break;
  55.     /*int*/
  56.     case F_DUPFD:
  57.     case F_DUPFD_CLOEXEC:
  58.     case F_SETFD:
  59.     case F_SETOWN:
  60.     case F_SETSIG:
  61.     case F_SETLEASE:
  62.     case F_NOTIFY:
  63.     case F_SETPIPE_SZ:
  64.     {
  65.         int arg = va_arg(va, int);
  66.         va_end(va);
  67.         return fcntl_f(fd, cmd, arg);
  69.     }
  70.     break;
  71.     /*void*/
  72.     case F_GETFD:
  73.     case F_GETOWN:
  74.     case F_GETSIG:
  75.     case F_GETLEASE:
  76.     case F_GETPIPE_SZ:
  77.     {
  78.         va_end(va);
  79.         return fcntl_f(fd, cmd);
  80.     }
  81.     break;
  83.     /*锁*/
  84.     case F_SETLK:
  85.     case F_SETLKW:
  86.     case F_GETLK:
  87.     case F_OFD_SETLK:
  88.     case F_OFD_SETLKW:
  89.     case F_OFD_GETLK:
  90.     {
  91.         struct flock* arg = va_arg(va, struct flock*);
  92.         va_end(va);
  93.         return fcntl_f(fd, cmd, arg);
  94.     }
  95.     break;
  97.     /*进程组*/
  98.     case F_GETOWN_EX:
  99.     case F_SETOWN_EX:
  100.     {
  101.         struct f_owner_ex* arg = va_arg(va, struct f_owner_ex*);
  102.         va_end(va);
  103.         return fcntl_f(fd, cmd, arg);
  104.     }
  105.     break;
  107.     default:
  108.         va_end(va);
  109.         return fcntl_f(fd, cmd);
  110.     }
  111. }

2.2.2.6 ioctl()

功能：作为IO操作的杂项补充。主要关注套接字的非阻塞状态，设置该状态时候用户态FdCtx的信息也改

  1. int ioctl(int fd, unsigned long request, ...)
  2. {
  3.     va_list va;
  4.     va_start(va, request);
  5.     void *arg = va_arg(va, void *);
  6.     va_end(va);
  8.     if(FIONBIO == request)
  9.     {
  10.         bool user_nonblock = *(int*)arg;
  12.         kit_server::FdCtx::ptr ctx = kit_server::FdMgr::GetInstance()->get(fd);
  14.         if(!ctx || ctx->isClose() || !ctx->isSocket())
  15.             return ioctl_f(fd, request, arg);     
  17.         ctx->setUserNonblock(user_nonblock);
  19.     }
  21.     return ioctl_f(fd, request, arg);
  22. }

2.2.2.7setsockopt()/getsockopt()

功能：设置/获取套接字的设置与属性。getsockopt()不需要进行HOOK操作;setsockopt()主要关注套接字收数据超时SO_RCVTIMEO/发数据超时SO_SNDTIMEO的设置，需要将信息也同步至用户态FdCtx

  1. //getsockopt 不需要hook
  2. int getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen)
  3. {
  4.     return getsockopt_f(sockfd, level, optname, optval, optlen);
  5. }
  7. //setsockopt
  8. int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen)
  9. {
  10.     if(!kit_server::t_hook_enable)
  11.         return setsockopt_f(sockfd, level, optname, optval, optlen);
  13.     if(level == SOL_SOCKET)
  14.     {
  15.         if(optname == SO_RCVTIMEO || optname == SO_SNDTIMEO)
  16.         {
  17.             kit_server::FdCtx::ptr ctx = kit_server::FdMgr::GetInstance()->get(sockfd);
  18.             if(ctx)
  19.             {
  20.                 const struct timeval *tv = (const struct timeval*)(optval);
  21.                 ctx->setTimeout(optname, tv->tv_sec * 1000 + tv->tv_usec / 1000);
  22.             }
  23.         }
  24.     }
  26.     return setsockopt_f(sockfd, level, optname, optval, optlen);
  27. }

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

功能：从一个动态链接库或者可执行文件获取到符号地址

  • 第一个参数：handle是一个指向已经加载动态目标的句柄，可由dlopen来获取。

    • 提供两种特殊伪句柄：
  1. RTLD_DEFAULT

使用默认的共享目标搜索顺序来找所需符号第一次出现的地方。这个搜索范围包含可执行文件中的全局符号以及这个可执行文件的依赖项（也就是使用RTLD_GLOBAL标志动态加载的共享目标）

  1. RTLD_NEXT (通常使用)

在当前搜索顺序中找，在当前的动态库之后加载进来的动态库中寻找对应符号的地址。 这就允许向在另一个共享目标中的函数提供一层封装。这样一来，在一个预先加载的共享目标中定义的函数中，就可以找到并调用在另一个共享目标中的真正要执行的函数

  • 第二个参数：symbol是一个以null结尾的符号名，即：某一个已经编译通过生成动态库的函数/变量
  1. #include <dlfcn.h>
  3. void *dlsym(void *handle, const char *symbol);
  4. Link with -ldl.
  • **first.c**：

gcc -fpic --shared first.c -o libfirst.so 编译为动态库的形式

  1. #include <stdio.h>
  2. #include <dlfcn.h>
  5. void print_msg()
  6. {
  7.     printf("hello im first lib\n");
  8. }
  10. void first()
  11. {
  12.     printf("first init\n");
  13. }
  • **second.c**：

gcc -fpic --shared second.c -o libsecond.so 编译为动态库的形式

  1. #include <stdio.h>
  2. #include <dlfcn.h>
  5. void print_msg()
  6. {
  7.     printf("hello im second lib\n");
  8. }
  10. void second()
  11. {
  12.     printf("second init\n");
  13. }
  • **wrap.c**：

gcc -fpic --shared wrap.c -o libwrap.so 编译为动态库的形式

  1. #define _GNU_SOURCE
  2. #include <stdio.h>
  3. #include <dlfcn.h>
  4. #include <unistd.h>
  5. #include <sys/types.h>
  6. #include <stdlib.h>
  10. void (*f)();
  11. void (*f1)();
  12. void (*f2)();
  14. //在main()函数之前 加载load_func()函数
  15. void load_func() __attribute__((constructor));
  17. void load_func()
  18. {
  19.     //打开libfirst.so动态库
  20.     void (*p1)() = (void (*)())dlopen("./libfirst.so", RTLD_NOW);
  21.     //打开libsecond.so动态库
  22.     void (*p2)() = (void (*)())dlopen("./libsecond.so", RTLD_NOW);
  23.     //从libfirst.so动态库中找出print_msg()
  24.     f1 = (void (*)())dlsym(p1, "print_msg");
  25.     //从libsecond.so动态库中找出print_msg()
  26.     f2 = (void (*)())dlsym(p2, "print_msg");
  28.     //使用dlsym 加载目标函数
  29.     f = (void (*)())dlsym(RTLD_NEXT, "print_msg");
  31.     char *s = dlerror();
  32.     if(s)
  33.         printf("dl error: %s\n", s);
  35.     /*验证究竟先加载的是哪一个库里的函数*/
  36.     printf("libfirst func is %p\n", f1);
  37.     printf("libsecond func is %p\n", f2);
  38.     printf("load first func is %p\n", f);
  40.     dlclose(p1);
  41.     dlclose(p2);
  42. }
  45. void print_msg()
  46. {
  48.     printf("hello im wrap lib\n");
  49.     f();
  50. }
  • **test_dl.c**:

gcc test_dl.c -c 编译为动态库的形式

  1. #include <stdio.h>
  2. #include <dlfcn.h>
  3. #include <errno.h>
  5. void print_msg();
  6. void first();
  7. void second();
  9. int main()
  10. {
  11.     first();
  12.     second();
  13.     print_msg();
  16.     return 0;
  17. }

执行程序前需要设置一下环境变量LD_LIBRARY_PATH主要用于查找共享库时除了默认路径外的其他路径;
此处是把当前路径加入到查找路径的意思
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:**.** “ . “ 表示当前目录加入到查找路径

  • 优先链接first.c：

gcc -o a test_dl.o -lwrap -lfirst -lsecond -ldl -L.
image.png

  • 优先链接second.c:

gcc -o a test_dl.o -lwrap -lsecond -lfirst -ldl -L.
image.png

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

功能：暂停当前线程的执行。直到指定的时间 req过去， 或发生中断。
req：存储指定的超时时间
rem：发生中断时，存储剩余的超时时间

  1. #include <time.h>
  3. int nanosleep(const struct timespec *req, struct timespec *rem);
  • 和**sleep()**、**usleep()**相比优势：
  1. 睡眠时间精度更高，能够到纳秒级别
  2. 不与信号交互，使得恢复被信号中断的休眠任务更加容易

C\C++知识点补充复习：attribute关键字

功能：主要是用来在函数或数据声明中设置其属性。给函数赋给属性的主要目的在于让编译器进行优化。attribute可以设置函数属性（Function Attribute）、变量属性（Variable Attribute）和类型属性（Type Attribute）

相关变量属性：

  • **__attribute__(aligned (xxx))**

指定变量或结构域的起始地址对齐（以字节为单位）

  1. int x __attribute__ ((aligned (16))) = 0;   // 16字节对齐
  3. struct foo {  
  5.     int x[2] __attribute__ ((aligned (8))); // 8字节对齐
  6. };
  • **__arrtibue__((packed))**

变量或结构域以最小对齐单位对齐，如变量以字节对齐，结构域以位对齐

  1. struct foo{        
  2.       char a;        
  3.       int x[2] __attribute__ ((packed)); // it immediately follows a      
  4. };

相关函数属性：

  • **__attribute__((constructor/destructor))**

该constructor属性使函数在执行进入之前被自动调用main ()。同样，destructor属性使函数在main ()完成或exit ()已被调用后自动调用。具有这些属性的函数对于初始化将在程序执行期间隐式使用的数据很有用。

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

功能：获取文件相关信息。依赖struct stat结构体返回获取我们需要的文件信息。

  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);
  9. struct stat {undefined
  10. dev_t     st_dev;             //  文件的设备编号
  11. ino_t     st_ino;             //  结点
  12. mode_t    st_mode;            //  文件的类型和存取的权限
  13. nlink_t   st_nlink;           // 连到该文件的硬链接数目，新建的文件则硬连接数为 1
  14. uid_t     st_uid;             // 用户ID
  15. gid_t     st_gid;             // 组ID
  16. dev_t     st_rdev;            // 若此文件为设备文件，则为其设备的编号
  17. off_t     st_size;              // 文件字节数(文件大小)
  18. blksize_t st_blksize;           // 块大小
  19. blkcnt_t  st_blocks;            // 块数
  20. time_t    st_atime;           //  最后一次访问时间
  21. time_t    st_mtime;           // 最后一次修改时间
  22. time_t    st_ctime;           // 最后一次改变时间
  23. };

  • 常关注：权限位mode_t st_mode该变量占 2 byte，共16位 

    1.         文件类型（12-15bit）<br />                       (a) 、S_IFSOCK   0140000   socket（套接字）<br />                       (b) 、S_IFLNK    0120000   symbolic link（符号链接--软连接）<br />                       (c) 、S_IFREG    0100000   regular file（普通文件）<br />                       (d)、 S_IFBLK    0060000   block device（块设备）                               <br />                       (e) 、S_IFDIR    0040000   directory（目录）<br />                       (f) 、 S_IFCHR    0020000   character device（字符设备）<br />                       (g)、 S_IFIFO    0010000   FIFO（管道）

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

功能：作为IO操作的杂项补充，终端IO是使用ioctl操作最多的地方。ioctl() 系统调用操作特殊文件的底层设备参数。 特别是，字符特殊文件（例如，终端）的许多操作特性可以通过 ioctl() 请求进行控制。

一般在驱动开发上是侧重点。

  1. #include <sys/ioctl.h>
  3. int ioctl(int fd, unsigned long request, ...);

C\C++知识点补充复习：setsockopt()、getsockopt()函数

功能：设置和获取socket套接字上的设置属性。

  • 一般情况下，将level置为SOL_SOCKET套接字级别设定属性。 ```cpp

    include

    include

int getsockopt(int sockfd, int level, int optname, void optval, socklen_t optlen); int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);

  2. - `**SOL_SOCKET**`**级别下，常用的套接字设置：**
  3. 1. `SO_REUSEADDR` 地址复用功能。
  5. 和TCP三次握手中`TIMEWAIT`状态有关，将这个参数置1的话，关闭`close/shutdown`的套接字的TCB    套接字控制块空间不会马上回收，会复用关闭连接的一些连接信息。<br />经典现象：TCP连接建立后，主动关闭服务器，导致的连接断开，不需要等待`TIMEWAIT`状态超时才释放连接，客户端再一次发起连接仍然能够连接成功服务器。
  7. 2. `SO_SNDBUF/ SO_RCVBUF` 设置发送/接收缓冲区的大小
  8. 2. `SO_KEEPALIVE` 套接字保活， 从内核层面开启TCP的keep-alive机制。
  9. 2. `SO_SNDTIMEO/SO_RCVTIMEO` 设置发送/接收超时时间，一旦超时不管数据收发成功与否立马返回
  11. <a name="Y6O5H"></a>
  12. # C\C++知识点补充复习：完美转发forward<>()函数
  13. **出处：《深入理解C++11新特性解析与应用》 P88**<br />概念：所谓完美转发（perfect forwarding），指在函数模板中，完全依照模板的参数类型，将参数传递给函数模板中调用的另一个函数。为了配合"右值引用"达到转发的"完美"，C++11引入了"引用折叠"的新语言规则。
  15. ```cpp
  16. typedef XX TR  /*XX的类型见下表*/
  18. TR& a = 1;
  19. TR&& b = 2;

image.png

自己通俗的理解：一个模板函数的参数的不确定的情况下，如果它的参数需要一个传入一个左值对象，forward()就会自动的传入一个左值；相反，需要一个右值对象，forward()就会自动传入一个右值。并且这样传参还不产生额外的开销。

  • 用例1 ```cpp

    include

    include

using namespace std;

void test(int &&v) { cout << “test1 run, v=” << v << endl; }

void test(int &v) { cout << “test2 run, v=” << v << endl; }

void test(const int &&v) { cout << “test3 run, v=” << v << endl; }

void test(const int &v) { cout << “test4 run, v=” << v << endl; }

template void RunTest(T &&v) { test(std::forward(v)); }

int main() { int a = 1; int b = 2; const int c = 3; const int d = 4;

  1. RunTest(a);                 //作为左值引用被转发
  2. RunTest(std::move(b));      //作为右值引用被转发
  3. RunTest(c);                 //作为const左值引用被转发
  4. RunTest(std::move(d));      //作为const右值引用被转发
  7. return 0;

}

  1. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/25460685/1644049877297-fe2b9eb9-6c0d-4eb8-9674-3a11a407411b.png#clientId=u329b0b2f-5593-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=104&id=u89b7b35f&margin=%5Bobject%20Object%5D&name=image.png&originHeight=104&originWidth=623&originalType=binary&ratio=1&rotation=0&showTitle=false&size=10657&status=done&style=none&taskId=uf0c48bba-6abd-4855-b7c9-febf6ac24cb&title=&width=623)
  3. - **用例2**
  4. ```cpp
  5. #include <iostream>
  7. using namespace std;
  9. class A
  10. {
  11. public:
  12.     A(int &&v) { cout << "int&&, v=" << v << endl;}
  13.     A(int &v) { cout << "int&, v=" << v << endl;}
  15. };
  17. class B
  18. {
  19. public:
  20.     template<class T1, class T2, class T3>
  21.     B(T1 &&t1, T2 &&t2, T3 &&t3):
  22.         _a1(std::forward<T1>(t1))
  23.         ,_a2(std::forward<T2>(t2))
  24.         ,_a3(std::forward<T3>(t3))
  25.     {
  26.         cout << "B coonstruct" << endl;
  27.     }
  29. private:
  30.     A _a1, _a2, _a3;
  31. };
  34. template<class T, class U>
  35. T run(U &&v)
  36. {
  37.     cout << "run1 run:";
  38.     return T(std::forward<U>(v));
  39. }
  42. template<class T, class ...U>
  43. T run(U&& ...v)
  44. {
  45.     cout << "run2 run:";
  46.     return T(std::forward<U>(v)...);
  47. }
  51. int main()
  52. {
  54.     auto a = run<A>(1);
  55.     int v = 2;
  56.     auto b = run<A>(v);
  58.     auto c = run<B>(1, v, 3);
  61.     return 0;
  62. }

image.png

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

出处：《UNIX 环境高级编程 第3版》P420
解决的问题：①read()读取不连续的内存/write()发送不连续的内存时，需要经过多次的read()/write()函数调用，就会造成不停地调用系统调用和数据拷贝，开销较大。②read()若干分批将数据读入不同区域/write()若干分批将不同区域的数据连续写入文件，也会①中类似的问题

概念：readv()/write()函数可以只通过一次系统调用和数据拷贝，就能完成在文件以及进程间多个缓冲区之间传递数据。（完成"scatter read"分散读、"gather write"集中写的功能）

  1. #include <sys/uio.h>
  3. /*iov ----- 数组首地址*/
  4. /*iovcnt------ 数组元素的个数*/
  5. ssize_t readv(int fd, const struct iovec *iov, int iovcnt);
  6. ssize_t writev(int fd, const struct iovec *iov, int iovcnt);
  8. /*依赖的系统定义的结构体*/
  9. struct iovec {
  10.     void  *iov_base;    /* Starting address 数据起始地址*/
  11.     size_t iov_len;     /* Number of bytes to transfer 数据缓存的大小*/
  12. };

image.png

  • 用例

image.png

  1. #include <iostream>
  2. #include <sys/uio.h>
  3. #include <sys/socket.h>
  4. #include <string.h>
  5. #include <unistd.h>
  6. #include <stdlib.h>
  7. #include <sys/types.h>
  8. #include <sys/stat.h>
  9. #include <fcntl.h>
  10. #include <errno.h>
  11. #include <fstream>
  13. using namespace std;
  16. int main()
  17. {
  19.     struct iovec iov[10];
  21.     for(int i = 0; i < 10;++i)
  22.     {
  23.         iov[i].iov_base = new char[10];
  24.         iov[i].iov_len = 10;
  25.     }
  27.     int fd = open("./tests/a.txt", O_RDONLY);
  28.     if(fd < 0)
  29.     {
  30.         cout << "open read erro, errno=" << errno << ",is:" << strerror(errno) << endl; 
  31.         return 0;
  32.     }
  34.     int ret = readv(fd, iov, 10);
  35.     if(ret < 0)
  36.     {
  37.         cout << "readv erro, errno=" << errno << ",is:" << strerror(errno) << endl; 
  38.         return 0;
  39.     }
  41.     cout << "read ret size = "<< ret << endl;
  42.     for(int i = 0; i < 10;++i)
  43.     {
  44.         cout << i << ": " << (char*)iov[i].iov_base << endl;
  45.     }
  46.     close(fd);
  48.     int fd2 = open("./tests/b.txt",  O_CREAT | O_RDWR, 0777);
  49.     if(fd2 < 0)
  50.     {
  51.         cout << "open write erro, errno=" << errno << ",is:" << strerror(errno) << endl; 
  52.         return 0;
  53.     }
  55.     ret = writev(fd2, iov, 10);
  56.     if(ret < 0)
  57.     {
  58.         cout << "readv erro, errno=" << errno << ",is:" << strerror(errno) << endl; 
  59.         return 0;
  60.     }
  62.     cout << "write ret size = "<< ret << endl;
  64.     close(fd2);
  67.     return 0;
  68. }

image.png

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

概念：就是recv()/write()、readv()/writev()函数的一个集合。这些函数的收发功能集合到了一起，方便使用。配置结构体struct msghdr的参数即可。

  1. #include <sys/types.h>
  2. #include <sys/socket.h>
  4. ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);
  5. ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
  7. struct iovec {                    /* Scatter/gather array items */
  8.    void  *iov_base;              /* Starting address */
  9.    size_t iov_len;               /* Number of bytes to transfer */
  10. };
  12. struct msghdr {
  13.    void         *msg_name;       /* Optional address */
  14.    socklen_t     msg_namelen;    /* Size of address */
  15.    struct iovec *msg_iov;        /* Scatter/gather array */
  16.    size_t        msg_iovlen;     /* # elements in msg_iov */
  17.    void         *msg_control;    /* Ancillary data, see below */
  18.    size_t        msg_controllen; /* Ancillary data buffer len */
  19.    int           msg_flags;      /* Flags on received message */
  20. };

C\C++知识点补充复习：可变参数列表va_list

概念：va_list是C语言中解决可变参数问题的一组宏，可以解决传入不确定个数的参数以及不确定类型的参数，没有名字与参数与之对应，使得传参非常的灵活。

  1.    #include <stdarg.h>
  3.    void va_start(va_list ap, last);
  4.    type va_arg(va_list ap, type);
  5.    void va_end(va_list ap);
  6.    void va_copy(va_list dest, va_list src);
  • 基本使用规则：
  1. 首先在函数里定义一个va_list型的变量，这个变量是指向参数的指针；
  2. 然后用VA_START宏初始化变量刚定义的va_list变量；
  3. 然后用va_arg返回可变的参数，va_arg的第二个参数是你要返回的参数的类型（如果函数有多个可变参数的，依次调用va_arg获取各个参数）
  4. 最后用va_end宏结束可变参数的获取。
  • 用例 ```cpp

    include

    include

using namespace std;

void test(int num, …) { va_list vl; va_start(vl, num);

  1. cout << "arg:";
  2. while(num--)
  3. {
  4.     cout << va_arg(vl, int) << " ";
  5. }
  7. cout << endl;
  8. va_end(vl);

}

int main() {

  1. test(2, 1, 2);
  2. test(4, 5, 6, 7, 8);
  5. return 0;

} ``` image.png