• sylar高性能服务器-日志(P43-P48)内容记录

    文章目录

    P43：Hook01

    sylar封装hook模块的目的就是让一些C标准库提供的同步API可以实现异步的性能。

    hook将API封装成一个与原始系统调用同名的接口，在调用这个接口时，先实现一些别的操作，然后在调用原始的系统API。这样对开发者来说很方便，不用重新学习新的接口，用着同步的接口实现异步的操作。

    一、HOOK

    将函数接口都存放到extern "C"作用域下，指定函数按照C语言的方式进行编译和链接。它的作用是为了解决C++中函数名重载的问题，使得C++代码可以和C语言代码进行互操作。

    定义接口函数指针
    extern "C" {

// 重新定义同名的接口

// sleep_fun 为函数指针
typedef unsigned int (*sleep_fun)(unsigned int seconds);
// 它是一个sleep_fun类型的函数指针变量，表示该变量在其他文件中已经定义，我们只是在当前文件中引用它。
extern sleep_fun sleep_f;

typedef int (*usleep_fun)(useconds_t usec);
extern usleep_fun usleep_f;

}

unsigned int sleep(unsigned int seconds) {
    if(!sylar::t_hook_enable) {
        return sleep_f(seconds);
    }

    sylar::Fiber::ptr fiber = sylar::Fiber::GetThis();
    sylar::IOManager* iom = sylar::IOManager::GetThis();
    iom->addTimer(seconds * 1000, std::bind((void(sylar::Scheduler::*)
            (sylar::Fiber::ptr, int thread))&sylar::IOManager::schedule
            ,iom, fiber, -1));
    sylar::Fiber::YieldToHold();
    return 0;

}

int usleep(useconds_t usec) {
    if(!sylar::t_hook_enable) {
        return usleep_f(usec);
    }

    sylar::Fiber::ptr fiber = sylar::Fiber::GetThis();
    sylar::IOManager* iom = sylar::IOManager::GetThis();
    iom->addTimer(usec / 1000, std::bind((void(sylar::Scheduler::*)
            (sylar::Fiber::ptr, int thread))&sylar::IOManager::schedule
            ,iom, fiber, -1));
    sylar::Fiber::YieldToHold();
    return 0;
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    获取接口原始地址

    使用宏来封装对每个原始接口地址的获取。

    #define HOOK_FUN(XX) \
    XX(sleep) \
    XX(usleep)

    • 1
    • 2
    • 3

    将hook_init()封装到一个结构体的构造函数中，并创建静态对象，能够在main函数运行之前就能将地址保存到函数指针变量当中。

    void hook_init() {
    static bool is_inited = false;
    if(is_inited) {
        return;
    }
// dlsym - 从一个动态链接库或者可执行文件中获取到符号地址。成功返回跟name关联的地址
// RTLD_NEXT 返回第一个匹配到的 "name" 的函数地址
// 取出原函数，赋值给新函数
#define XX(name) name ## _f = (name ## _fun)dlsym(RTLD_NEXT, #name);
    HOOK_FUN(XX);
#undef XX
}

struct _HookIniter {
    _HookIniter() {
        hook_init();
    }
};

static _HookIniter s_hook_initer;

extern "C" {
// 声明变量
#define XX(name) name ## _fun name ## _f = nullptr;
    HOOK_FUN(XX);
#undef XX
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    上面的宏展开如下

    extern "C" {
	sleep_fun sleep_f = nullptr;
    usleep_fun usleep_f = nullptr;
}

void hook_init() {
    static bool is_inited = false;
    if (is_inited) {
        return;
    }
    
	sleep_f = (sleep_fun)dlsym(RTLD_NEXT, "sleep");
    usleep_f = (usleep_fun)dlsym(RTLD_NEXT, "usleep");

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    二、测试

    #include"../sylar/hook.h"
#include"../sylar/log.h"
#include"../sylar/iomanager.h"

sylar::Logger::ptr g_logger = SYLAR_LOG_ROOT();

void test_sleep() {
    SYLAR_LOG_INFO(g_logger) << "start()_HY";
    sylar::IOManager iom(1);
    iom.schedule([](){
        sleep(2);
        SYLAR_LOG_INFO(g_logger) << "sleep 2";
    });

    iom.schedule([](){
        sleep(3);
        SYLAR_LOG_INFO(g_logger) << "sleep 3";
    });
    SYLAR_LOG_INFO(g_logger) << "test_sleep";
}

int main(int argc, char** argv) {
    test_sleep();
    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    上面测试用例通过IOManager进行两次调度，第一个任务睡眠2s，第二个任务睡眠3s

    不开启hook

    在不开启hook的情况下，两个任务必须按着顺序执行，也就是一共需要5s时间

    image-20240226193319313

    开启hook

    在执行hook情况下，第一个任务在执行sleep时就添加一个2s的定时器，利用回调函数去调度本协程，然后让协程让出执行权去处理第二个任务，这样完成两个任务一共只需要3s，通过hook让只能同步的sleep实现了异步的效果

    unsigned int sleep(unsigned int seconds) {
    if(!sylar::t_hook_enable) {
        return sleep_f(seconds);
    }

    sylar::Fiber::ptr fiber = sylar::Fiber::GetThis();
    sylar::IOManager* iom = sylar::IOManager::GetThis();
    iom->addTimer(seconds * 1000, std::bind((void(sylar::Scheduler::*)
            (sylar::Fiber::ptr, int thread))&sylar::IOManager::schedule
            ,iom, fiber, -1));
    sylar::Fiber::YieldToHold();
    return 0;

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    image-20240226193645237

    P44-P48：Hook02-06

    以下记录参考博客链接

    一、hook实现基础

    ​ 通过动态库的全局符号介入，使用自定义的接口替换掉同名的系统调用接口。

    ​ 系统调用接口基本上是由C标准函数库libc提供，所以这里要做的事情就是用自定义的动态库来覆盖掉libc中的同名符号。

    ​ 由于动态库的全局符号介入问题，全局符号表只会记录第一次识别到的符号，后续的同名符号都被忽略，但这并不表示同名符号所在的动态库完全不会加载，因为有可能其他的符号会用到。

    ​ 以libc库举例，如果用户在链接libc库之前链接了一个指定的库，并且在这个库里实现了read/write接口，那么在程序运行时，程序调用的read/write接口就是指定库里的，而不是libc库里的。libc库仍然会被加载，因为libc库是程序的运行时库，程序不可能不依赖libc里的其他接口。因为libc库也被加载了，所以，通过一定的手段，仍然可以从libc中拿到属于libc的read/write接口，这就为hook创建了条件。程序可以定义自己的read/write接口，在接口内部先实现一些相关的操作，然后再调用libc里的read/write接口。（写得真清楚！）

    而将libc库中的接口重新找回来的方法就是使用dlsym()

    #include 

/*
 * 第一个参数固定为 RTLD_NEXT，第二个参数为符号的名称
 */
void *dlsym(void *handle, const char *symbol);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    二、class FdCtx

    FdCtx存储每一个fd相关的信息，并由FdManager管理每一个FdCtx，FdManager为单例类

    成员变量
    // 是否初始化
bool m_isInit: 1;
// 是否Socket
bool m_isSocket: 1;
// 是否hook非阻塞
bool m_sysNonblock: 1;
// 是否用户主动设置非阻塞
bool m_userNonblock: 1;
// 是否关闭
bool m_isClosed: 1;
// 文件句柄
int m_fd;
// 读超时时间毫秒
uint64_t m_recvTimeout;
// 写超时时间毫秒
uint64_t m_sendTimeout;
sylar::IOManager* m_iomanager;

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    构造函数
    // 构造函数
FdCtx::FdCtx(int fd)
    : m_isInit(false)
    , m_isSocket(false)
    , m_sysNonblock(false)
    , m_userNonblock(false)
    , m_isClosed(false)
    , m_fd(fd)
    , m_recvTimeout(-1)
    , m_sendTimeout(-1) {
    init();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    init
    // 初始化
bool FdCtx::init() {
    // 如果已经初始化直接返回true
    if(m_isInit) {
        return true;
    }
    // 默认发送/接收超时时间
    m_recvTimeout = -1;
    m_sendTimeout = -1;

    // 定义一个stat结构体
    struct stat fd_stat;
    // 通过文件描述符取得文件的状态,返回-1失败
    if(-1 == fstat(m_fd, &fd_stat)) {
        // 初始化失败并且不是Socket
        m_isInit = false;
        m_isSocket = false;
    } else {
        // 初始化成功
        m_isInit = true;
        // S_ISSOCK (st_mode) 是否为socket 
        m_isSocket = S_ISSOCK(fd_stat.st_mode);
    }

    // 如果是socket，则给它设置为阻塞状态
    if(m_isSocket) {
        // 获取文件的flags
        int flags = fcntl_f(m_fd, F_GETFL, 0);
        // 判断是否是阻塞的
        if(!(flags & O_NONBLOCK)) {
            // 不是则设置为阻塞
            fcntl_f(m_fd, F_SETFL, flags | O_NONBLOCK);
        }
        // 阻塞设置生效
        m_sysNonblock = true;
    } else {
        // 不是Socket则不管
        m_sysNonblock = false;
    }
    // 初始化用户没有设置为阻塞
    m_userNonblock = false;
    // 未关闭
    m_isClosed = false;
    // 反正初始化状态
    return m_isInit;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    strcut stat

    struct stat    
{    
    dev_t       st_dev;     /* ID of device containing file -文件所在设备的ID*/    
    ino_t       st_ino;     /* inode number -inode节点号*/  
    mode_t      st_mode;    /* 文件的类型和存取的权限*/    
    nlink_t     st_nlink;   /* number of hard links -链向此文件的连接数(硬连接)*/    
    uid_t       st_uid;     /* user ID of owner -user id*/    
    gid_t       st_gid;     /* group ID of owner - group id*/    
    dev_t       st_rdev;    /* device ID (if special file) -设备号，针对设备文件*/    
    off_t       st_size;    /* total size, in bytes -文件大小，字节为单位*/    
    blksize_t   st_blksize; /* blocksize for filesystem I/O -系统块的大小*/    
    blkcnt_t    st_blocks;  /* number of blocks allocated -文件所占块数*/    
    time_t      st_atime;   /* time of last access -最近存取时间*/    
    time_t      st_mtime;   /* time of last modification -最近修改时间*/    
    time_t      st_ctime;   /* time of last status change - */    
};    

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    fstat

    通过文件描述符取得文件的状态

    int fstat (int __fd, struct stat *__buf)

    • 1
    setTimeout
    // 设置超时时间
void FdCtx::setTimeout(int type, uint64_t v) {
    // 套接字为设置Socket接收数据的超时时间
    if(type == SO_RCVTIMEO) {
        m_recvTimeout = v;
    } else {
        m_sendTimeout = v;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    getTimeout
    // 获取超时时间
uint64_t FdCtx::getTimeout(int type) {
    if(type == SO_RCVTIMEO) {
        return m_recvTimeout;
    } else {
        return m_sendTimeout;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    三、class FdManager

    成员变量
    // 读写锁
RWMutexType m_mutex;
// 文件句柄集合
std::vector<FdCtx::ptr> m_datas;

    • 1
    • 2
    • 3
    • 4
    构造函数
    // 构造函数
FdManager::FdManager() {
    m_datas.resize(64);
}

    • 1
    • 2
    • 3
    • 4
    get（获取/创建文件句柄类）
    // 获取/创建文件句柄类
FdCtx::ptr FdManager::get(int fd, bool auto_create) {
    RWMutexType::ReadLock lock(m_mutex);
    // 表示集合中没有，并且也不自动创建，直接返回空指针
    if((int)m_datas.size() <= fd) {
        if(auto_create ==false) {
            return nullptr;
        }
    } else {
        // 当前有值或者不需要创建，直接返回目标值
        if(m_datas[fd] || !auto_create) {
            return m_datas[fd];
        }
    }
    lock.unlock();
    // 自动创建
    RWMutexType::WriteLock lock2(m_mutex);
    FdCtx::ptr ctx(new FdCtx(fd));
    m_datas[fd] = ctx;
    return ctx;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    del（删除文件句柄类）
    // 删除文件句柄类
void FdManager::del(int fd) {
    RWMutexType::WriteLock lock(m_mutex);
    // 没找到直接返回
    if((int)m_datas.size() <= fd) {
        return;
    }
    // 删除
    m_datas[fd].reset();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    四、class hook

    这里补充一些函数方法

    do_io（socket操作真正执行体）

    流程

    • 先进行一系列判断，是否按原函数执行。

    • 执行原始函数进行操作，若errno = EINTR，则为系统中断，应该不断重新尝试操作。

    • 若errno = EAGIN，系统已经隐式的将socket设置为非阻塞模式，此时资源咱不可用。

    • 若设置了超时时间，则设置一个执行周期为超时时间的条件定时器，它保证若在超时之前数据就已经来了，然后操作完do_io执行完毕，智能指针tinfo已经销毁了，但是定时器还在，此时弱指针拿到的就是个空指针，将不会执行定时器的回调函数。

    • 在条件定时器的回调函数中设置错误为ETIMEDOUT超时，并且使用cancelEvent强制执行该任务，继续回到该协程执行。

    • 通过addEvent添加事件，若添加事件失败，则将条件定时器删除并返回错误。成功则让出协程执行权。

    • 只有两种情况协程会被拉起： a. 超时了，通过定时器回调函数 cancelEvent ---> triggerEvent会唤醒回来 b. addEvent数据回来了会唤醒回来

    • 将定时器取消，若为超时则返回-1并设置errno = ETIMEDOUT，并返回-1。

    • 若为数据来了则retry，重新操作。

    定时器
    // 定时器超时条件
struct timer_info {
    int cancelled = 0;
};

    • 1
    • 2
    • 3
    • 4
    do_io

    /*

    * fd 文件描述符

    * fun 原始函数

    * hook_fun_name hook的函数名称

    * event 事件

    * timeout_so 超时时间类型

    * args 可变参数

    *

    * 例如：return do_io(fd, read_f, “read”, sylar::IOManager::READ, SO_RCVTIMEO, buf, count);

    */

    template<typename OriginFun, typename... Args>
static ssize_t do_io(int fd, OriginFun fun, const char* hook_fun_name,
        uint32_t event, int timeout_so, Args&&... args) {
    // 非hook直接返回原接口
    if(!sylar::t_hook_enable) {
        /* 可以将传入的可变参数args以原始类型的方式传递给函数fun。
         * 这样做的好处是可以避免不必要的类型转换和拷贝，提高代码的效率和性能。*/
        return fun(fd, std::forward<Args>(args)...);
    }
    // 通过文件句柄获得对应的FdCtx
    sylar::FdCtx::ptr ctx = sylar::FdMgr::GetInstance()->get(fd);
    // 没有文件调原接口
    if(!ctx) {
        return fun(fd, std::forward<Args>(args)...);
    }
    // 如果句柄已经关闭
    if(ctx->isClose()) {
        // #define	EBADF		 9	/* Bad file number */
        errno = EBADF;
        return -1;
    }
    // 如果不是Socket或者用户设置了非阻塞，仍然调原接口
    if(!ctx->isSocket() || ctx->getUserNonblock()) {
        return fun(fd, std::forward<Args>(args)...);
    }
    // ------ hook要做了 ------异步IO
    // 获得超时时间
    uint64_t to = ctx->getTimeout(timeout_so);
    // 设置超时条件
    std::shared_ptr<timer_info> tinfo(new timer_info);

retry:
    // 先执行fun 读数据或写数据 若函数返回值有效就直接返回
    // std::forward 是一个 C++11 中的模板函数，其主要作用是在模板函数或模板类中，
    // 将一个参数以“原样”（forward）的方式转发给另一个函数
    ssize_t n = fun(fd, std::forward<Args>(args)...);
    // 若中断则重试
    // #define	EINTR		 4	/* Interrupted system call */
    while(n == -1 && errno == EINTR) {
        n = fun(fd, std::forward<Args>(args)...);
    }
    // 重试
    // #define	EAGAIN		11	/* Try again */
    if(n == -1 && errno == EAGAIN) {
        // 获得当前IO调度器
        sylar::IOManager* iom = sylar::IOManager::GetThis();
        // 定时器
        sylar::Timer::ptr timer;
        // tinfo的弱指针，可以判断tinfo是否已经销毁
        std::weak_ptr<timer_info> winfo(tinfo);
        // 设置了超时时间
        if(to != (uint64_t)-1) {
            // 添加条件定时器
            // to时间到了消息还没来就触发callback
            timer = iom->addConditionTimer(to, [winfo, fd, iom, event]() {
                auto t = winfo.lock();
                // 定时器失效
                if(!t || t->cancelled) {
                    return;
                }
                // 没错误的话设置为超时而失败
                // #define	ETIMEDOUT	110	/* Connection timed out */
                t->cancelled = ETIMEDOUT;
                // 取消事件强制唤醒
                iom->cancelEvent(fd, (sylar::IOManager::Event)(event));
            }, winfo);
        }
        // 默认cb为空，任务执行当前协程
        int rt = iom->addEvent(fd, (sylar::IOManager::Event)(event));
        // addEvent失败， 取消上面加的定时器
        if(rt) {
            SYLAR_LOG_ERROR(g_logger) << hook_fun_name << " addEvent("
                << fd << ", " << event << ")";
            if(timer) {
                timer->cancel();
            }
            return -1;
        } else {
            /*	addEvent成功，把执行时间让出来
             *	只有两种情况会从这回来：
             * 	1) 超时了， timer cancelEvent triggerEvent会唤醒回来
             * 	2) addEvent数据回来了会唤醒回来 
            */
            SYLAR_LOG_DEBUG(g_logger) << "do_io <" << hook_fun_name << ">";
            sylar::Fiber::YieldToHold();
            SYLAR_LOG_DEBUG(g_logger) << "do_io <" << hook_fun_name << ">";
            if(timer) {
                timer->cancel();
            }
            // 从定时任务唤醒，超时失败
            if(tinfo->cancelled) {
                errno = tinfo->cancelled;
                return -1;
            }
            // 数据来了就直接重新去操作
            goto retry;
        }
    }
    return n;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    sleep系列

    设置一个定时器然后让出执行权，超时后继续执行该协程。

    回调函数使用std::bind函数将sylar::IOManager::schedule函数绑定到iom对象上，并传入fiber和-1两个参数。由于schedule是个模板类，如果直接与函数绑定，就无法确定函数的类型，从而无法使用std::bind函数。因此，需要先声明函数指针，将函数的类型确定下来，然后再将函数指针与std::bind函数进行绑定。

    unsigned int sleep(unsigned int seconds) {
    if(!sylar::t_hook_enable) {
        return sleep_f(seconds);
    }

    sylar::Fiber::ptr fiber = sylar::Fiber::GetThis();
    sylar::IOManager* iom = sylar::IOManager::GetThis();
     /**
     * 	@details
     *
     *	(void(sylar::Scheduler::*)(sylar::Fiber::ptr, int thread)) 是一个函数指针类型，
     *	它定义了一个指向 sylar::Scheduler 类中一个参数为 sylar::Fiber::ptr 和 int 类型的成员函数的指针类型。
     *	具体来说，它的含义如下：
     *	void 表示该成员函数的返回值类型，这里是 void 类型。
     *	(sylar::Scheduler::*) 表示这是一个 sylar::Scheduler 类的成员函数指针类型。
     *	(sylar::Fiber::ptr, int thread) 表示该成员函数的参数列表
     *       ，其中第一个参数为 sylar::Fiber::ptr 类型，第二个参数为 int 类型。
     *	
     *	使用 std::bind 绑定了 sylar::IOManager::schedule 函数，
     * 	并将 iom 实例作为第一个参数传递给了 std::bind 函数，将sylar::IOManager::schedule函数绑定到iom对象上。
     * 	在这里，第二个参数使用了函数指针类型 (void(sylar::Scheduler::*)(sylar::Fiber::ptr, int thread))
     * 	，表示要绑定的函数类型是 sylar::Scheduler 类中一个参数为 sylar::Fiber::ptr 和 int 类型的成员函数
     * 	，这样 std::bind 就可以根据这个函数类型来实例化出一个特定的函数对象，并将 fiber 和 -1 作为参数传递给它。
     */

    iom->addTimer(seconds * 1000, std::bind((void(sylar::Scheduler::*)
            (sylar::Fiber::ptr, int thread))&sylar::IOManager::schedule
            ,iom, fiber, -1));
    sylar::Fiber::YieldToHold();
    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    Socket系列
    int socket(int domain, int type, int protocol) {
    if(!sylar::t_hook_enable) {
        return socket_f(domain, type, protocol);
    }
    int fd = socket_f(domain, type, protocol);
    if(fd == -1) {
        return fd;
    }
    // 将fd放入到文件管理中
    sylar::FdMgr::GetInstance()->get(fd, true);
    return fd;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    connect系列
    int connect_with_timeout(int fd, const struct sockaddr* addr, socklen_t addrlen, uint64_t timeout_ms) {
    if(!sylar::t_hook_enable) {
        return connect_f(fd, addr, addrlen);
    }
    sylar::FdCtx::ptr ctx = sylar::FdMgr::GetInstance()->get(fd);
    if(!ctx || ctx->isClose()) {
        errno = EBADF;
        return -1;
    }

    if(!ctx->isSocket()) {
        return connect_f(fd, addr, addrlen);
    }

    if(ctx->getUserNonblock()) {
        return connect_f(fd, addr, addrlen);
    }
    // 异步开始
    // 尝试连接
    int n = connect_f(fd, addr, addrlen);
    // 连接成功
    if(n == 0) {
        return 0;
    // 失败 #define	EINPROGRESS	115	/* Operation now in progress */
    } else if(n != -1 || errno != EINPROGRESS) {
        return n;
    }

    sylar::IOManager* iom = sylar::IOManager::GetThis();
    sylar::Timer::ptr timer;
    std::shared_ptr<timer_info> tinfo(new timer_info);
    std::weak_ptr<timer_info> winfo(tinfo);

    // 设置了超时时间
    if(timeout_ms != (uint64_t)-1) {
        // 加条件定时器
        timer = iom->addConditionTimer(timeout_ms, [winfo, fd, iom]() {
                auto t = winfo.lock();
                if(!t || t->cancelled) {
                    return;
                }
                t->cancelled = ETIMEDOUT;
                iom->cancelEvent(fd, sylar::IOManager::WRITE);
        }, winfo);
    }
    // 添加一个写事件
    int rt = iom->addEvent(fd, sylar::IOManager::WRITE);
    if(rt == 0) {
        /* 	只有两种情况唤醒：
         * 	1. 超时，从定时器唤醒
         *	2. 连接成功，从epoll_wait拿到事件 */
        sylar::Fiber::YieldToHold();
        if(timer) {
            timer->cancel();
        }
        // 从定时器唤醒，超时失败
        if(tinfo->cancelled) {
            errno = tinfo->cancelled;
            return -1;
        }
    } else {
        // 添加事件失败
        if(timer) {
            timer->cancel();
        }
        SYLAR_LOG_ERROR(g_logger) << "connect addEvent(" << fd << ", WRITE) error";
    }

    int error = 0;
    socklen_t len = sizeof(int);
    // 获取套接字的错误状态
    if(-1 == getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len)) {
        return -1;
    }
    // 没有错误，连接成功
    if(!error) {
        return 0;
    } else {
        errno = error;
        return -1;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    accept
    int accept(int s, struct sockaddr *addr, socklen_t *addrlen) {
    int fd = do_io(s, accept_f, "accept", sylar::IOManager::READ, SO_RCVTIMEO, addr, addrlen);
    // 将新创建的连接放到文件管理中
    if(fd >= 0) {
        sylar::FdMgr::GetInstance()->get(fd, true);
    }
    return fd;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    close
    int close(int fd) {
    if(!sylar::t_hook_enable) {
        return close_f(fd);
    }

    sylar::FdCtx::ptr ctx = sylar::FdMgr::GetInstance()->get(fd);
    if(ctx) {
        auto iom = sylar::IOManager::GetThis();
        // 取消事件
        if(iom) {
            iom->cancelAll(fd);
        }
        // 在文件管理中删除
        sylar::FdMgr::GetInstance()->del(fd);
    }
    return close_f(fd);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    fcntl（修改文件状态）

    int fcntl(int fd, int cmd, ... /* arg */ ) {
    va_list va;
    va_start(va, cmd);
    switch(cmd) {
        case F_SETFL:
            {
                int arg = va_arg(va, int);
                va_end(va);
                sylar::FdCtx::ptr ctx = sylar::FdMgr::GetInstance()->get(fd);
                if(!ctx || ctx->isClose() || !ctx->isSocket()) {
                    return fcntl_f(fd, cmd, arg);
                }
                ctx->setUserNonblock(arg & O_NONBLOCK);
                if(ctx->getSysNonblock()) {
                    arg |= O_NONBLOCK;
                } else {
                    arg &= ~O_NONBLOCK;
                }
                return fcntl_f(fd, cmd, arg);
            }
            break;
        case F_GETFL:
            {
                va_end(va);
                int arg = fcntl_f(fd, cmd);
                sylar::FdCtx::ptr ctx = sylar::FdMgr::GetInstance()->get(fd);
                if(!ctx || ctx->isClose() || !ctx->isSocket()) {
                    return arg;
                }
                if(ctx->getUserNonblock()) {
                    return arg | O_NONBLOCK;
                } else {
                    return arg & ~O_NONBLOCK;
                }
            }
            break;
        case F_DUPFD:
        case F_DUPFD_CLOEXEC:
        case F_SETFD:
        case F_SETOWN:
        case F_SETSIG:
        case F_SETLEASE:
        case F_NOTIFY:
#ifdef F_SETPIPE_SZ
        case F_SETPIPE_SZ:
#endif
            {
                int arg = va_arg(va, int);
                va_end(va);
                return fcntl_f(fd, cmd, arg); 
            }
            break;
        case F_GETFD:
        case F_GETOWN:
        case F_GETSIG:
        case F_GETLEASE:
#ifdef F_GETPIPE_SZ
        case F_GETPIPE_SZ:
#endif
            {
                va_end(va);
                return fcntl_f(fd, cmd);
            }
            break;
        case F_SETLK:
        case F_SETLKW:
        case F_GETLK:
            {
                struct flock* arg = va_arg(va, struct flock*);
                va_end(va);
                return fcntl_f(fd, cmd, arg);
            }
            break;
        case F_GETOWN_EX:
        case F_SETOWN_EX:
            {
                struct f_owner_exlock* arg = va_arg(va, struct f_owner_exlock*);
                va_end(va);
                return fcntl_f(fd, cmd, arg);
            }
            break;
        default:
            va_end(va);
            return fcntl_f(fd, cmd);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    ioctl（对设备进行控制操作）
    int ioctl(int d, unsigned long int request, ...) {
    va_list va;
    va_start(va, request);
    void* arg = va_arg(va, void*);
    va_end(va);
    //	FIONBIO用于设置文件描述符的非阻塞模式
    if(FIONBIO == request) {
        bool user_nonblock = !!*(int*)arg;
        sylar::FdCtx::ptr ctx = sylar::FdMgr::GetInstance()->get(d);
        if(!ctx || ctx->isClose() || !ctx->isSocket()) {
            return ioctl_f(d, request, arg);
        }
        ctx->setUserNonblock(user_nonblock);
    }
    return ioctl_f(d, request, arg);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    setsockopt（设置Socket）

    int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen) {
    if(!sylar::t_hook_enable) {
        return setsockopt_f(sockfd, level, optname, optval, optlen);
    }
    // 如果设置socket通用选项
    if(level == SOL_SOCKET) {
         // 如果设置超时选项
        if(optname == SO_RCVTIMEO || optname == SO_SNDTIMEO) {
            sylar::FdCtx::ptr ctx = sylar::FdMgr::GetInstance()->get(sockfd);
            if(ctx) {
                const timeval* v = (const timeval*)optval;
                // 转为毫秒保存
                ctx->setTimeout(optname, v->tv_sec * 1000 + v->tv_usec / 1000);
            }
        }
    }
    return setsockopt_f(sockfd, level, optname, optval, optlen);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    五、测试

    代码

        int sock = socket(AF_INET, SOCK_STREAM, 0);
    sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(80);
    inet_pton(AF_INET, "183.2.172.185", &addr.sin_addr.s_addr);
    SYLAR_LOG_INFO(g_logger) << "begin connect";
    int rt = connect(sock, (const sockaddr*)&addr, sizeof(addr));
    SYLAR_LOG_INFO(g_logger) << "connect rt = " << " errno = " << errno;
    if(rt) {
        return;
    }
    // 发送消息
    const char data[] = "GET / HTTP/1.0\r\n\r\n";
    rt = send(sock,data,sizeof(data), 0);
    SYLAR_LOG_INFO(g_logger) << "send rt = " << rt << " error = " << errno;
    if(rt <= 0) {
        return;
    }

    // 接收消息
    std::string buff;
    buff.resize(4096);

    rt = recv(sock, &buff[0], buff.size(), 0);
    SYLAR_LOG_INFO(g_logger) << "recv rt = " << rt << " errno = " << errno;

    if(rt <= 0) {
        return;
    }
    buff.resize(rt);
    SYLAR_LOG_INFO(g_logger) << buff;

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    结果

    image-20240228165004953

  • 相关阅读:
    求两个单链表的交点
    python 中__init__ 作用
    xml 里面判断int类型，String类型不为空
    ＜Linux系统复习＞文件系统的理解
    【生物信息学】使用皮尔逊相关系数进行相关性分析
    快手直播弹幕websocket protobuf序列化与反序列化
    如何使用PHP替换回车为br
    23.网络游戏逆向分析与漏洞攻防-网络通信数据包分析工具-实现配置工具数据结构
    私有化轻量级持续集成部署方案--06-私有镜像仓库-Harbor
    Java垃圾回收_1
  • 原文地址：https://blog.csdn.net/qq_18824403/article/details/136350572