macOS 内核拓展与用户态进程的通信实现（一）

macOS 内核拓展与用户态进程通信基本依靠 KernControl  API 及 IOKit Fundamentals  框架。kern_control API 对 socket 进行简单封装，用户态进程调用connect建立与内核的通信机制。IOKit 则不仅提供用户态通信接口，实际上 IOKit 提供所有内核驱动的管控能力，包含驱动的注册、资源管理和调试等。

KernControl 内核编程

内核拓展需调用ctl_register进行控制器的注册。函数原型为：errno_t ctl_register(struct kern_ctl_reg *userkctl, kern_ctl_ref *kctlref);。其中userkctl存放控制器相关配置，kctlref用于后续的消息发送和最后的控制器注销。消息传输调用ctl_enqueuedata实现，函数原型为errno_t ctl_enqueuedata(kern_ctl_ref kctlref, u_int32_t unit, void *data, size_t len, u_int32_t flags);。需要注意的是数据传输使用到的unit需在连接建立时获取，详见下面kext_connect函数实现。
kern_ctl_reg结构体包含数据分发相关的函数指针，需自行实现。

/**
 * @brief Kext管控运行时环境
 */
typedef struct {
    struct kern_ctl_reg kctl_register;      // kext注册器
    kern_ctl_ref kctl_refrance;             // kext注册引用
    uint8_t kext_unit;                      // kext单元号
    bool is_connected;                      // kext连接状态
} KextControlEnv;
KextControlEnv g_kext_ctl;                      // 内核拓展控制器

/**
 * @brief   kext控制器初始化
 * @return  错误码
 */
errno_t kext_control_init(void) {
    errno_t error = KERN_SUCCESS;
    bzero(&g_kext_ctl, sizeof(KextControlEnv));

    // 初始化kext管控参数
    strlcpy(g_kext_ctl.kctl_register.ctl_name, "your kext name", MAX_KCTL_NAME);
    g_kext_ctl.kctl_register.ctl_flags = CTL_FLAG_PRIVILEGED;
    g_kext_ctl.kctl_register.ctl_send = kext_send;
    g_kext_ctl.kctl_register.ctl_getopt = sock_get_opt;
    g_kext_ctl.kctl_register.ctl_setopt = sock_set_opt;
    g_kext_ctl.kctl_register.ctl_connect = kext_connect;
    g_kext_ctl.kctl_register.ctl_disconnect = kext_disconnect;

    // 注册kext控制器
    error = ctl_register(&g_kext_ctl.kctl_register, &g_kext_ctl.kctl_refrance);
    if (error != KERN_SUCCESS) {
        LOG_C(LOG_ERROR, "Failed to register kext controller with error code [%d].", error);
    }

    return error;
}

/**
 * @brief   kext控制器反初始化
 * @return  错误码
 */
errno_t kext_control_uninit(void) {
    errno_t error = KERN_SUCCESS;

    error = ctl_deregister(g_kext_ctl.kctl_refrance);
    if (error != KERN_SUCCESS) {
        LOG_C(LOG_ERROR, "Failed to deregister kext controller with error code [%d].", error);
    }

    return error;
}

/**
 * @brief           客户端设置配置回调
 * @param ctlref    kext控制引用
 * @param unit      kext单元号
 * @param command   操作标志
 * @return          错误码
 */
errno_t sock_set_opt(kern_ctl_ref ctlref, unsigned int unit, void *info, int command, void *data, size_t len) {
    errno_t err_code = KERN_SUCCESS;

    switch (command) {
        // TODO
    }

    return err_code;
}

/**
 * @brief           客户端获取配置回调
 * @param ctlref    kext控制引用
 * @param unit      kext单元号
 * @param opt       操作标志
 * @return          错误码
 */
errno_t sock_get_opt(kern_ctl_ref ctlref, unsigned int unit, void *userdata, int opt, void *data, size_t *len) {
    // 可不用实现
    return KERN_SUCCESS;
}

/**
 * @brief           客户端连接回调
 * @param ctlref    kext控制引用
 * @param sac       套接字地址控制器
 * @return          错误码
 */
errno_t kext_connect(kern_ctl_ref ctlref, struct sockaddr_ctl *sac, void **unitinfo) {
    errno_t err_code = KERN_SUCCESS;

    if (g_kext_ctl.is_connected == true) {
        LOG_C(LOG_ERROR, "Failed to accept the connection request for a connection already established.");
        err_code = EISCONN;
        return err_code;
    }

    g_kext_ctl.is_connected = true;
    g_kext_ctl.kext_unit = sac->sc_unit;
    LOG_C(LOG_INFO, "Connect with client successfully.");

    return err_code;
}

/**
 * @brief           客户端断开连接回调
 * @param ctlref    kext控制引用
 * @param unit      kext单元号
 * @return          错误码
 */
errno_t kext_disconnect(kern_ctl_ref ctlref, unsigned int unit, void *unitinfo) {
    g_kext_ctl.is_connected = false;
    LOG_C(LOG_INFO, "Disconnect with peer successfully.");

    return KERN_SUCCESS;
}

KernControl 用户态编程

用户态进程仅需调用connect函数发起连接，代码如下。OS X 专门为内核通信定义了PF_SYSTEM域，该域支持SYSPROTO_CONTROL和SYSPROTO_EVENT两个协议。使用SYSPROTO_CONTROL协议的内核控制（kern_control）API 允许应用程序配置和控制 KEXT。使用SYSPROTO_EVENT协议的内核事件（kern_event）API 允许在某些内核事件发生时通知应用程序和其他 KEXT。一般来说，内核控制 API 是首选，因为它提供双向通信。

/**
 * @brief  连接内核拓展
 * @return NO表示失败，否则成功
 */
- (BOOL)establishConnection {
    if (self.socketFD != -1) {
        return YES;
    }

    // 创建kext管控套接字
    _socketFD = socket(PF_SYSTEM, SOCK_DGRAM, SYSPROTO_CONTROL);
    if (self.socketFD == -1) {
        LOG_OC(LOG_ERROR, "Could not create socket.");
        return NO;
    }

    // 初始化kext控制信息
    struct ctl_info info;
    bzero(&info, sizeof(info));
    strlcpy(info.ctl_name, "your kext name", MAX_KCTL_NAME);

    // 获取动态设置的kext ID
    if (ioctl(self.socketFD, CTLIOCGINFO, &info)) {
        LOG_OC(LOG_ERROR, "Could not get ID for kernel control.");
        return NO;
    }

    // 初始化套接字连接地址
    struct sockaddr_ctl addr;
    bzero(&addr, sizeof(addr));
    addr.sc_len = sizeof(addr);
    addr.sc_family = AF_SYSTEM;
    addr.ss_sysaddr = AF_SYS_CONTROL;
    addr.sc_id = info.ctl_id;
    addr.sc_unit = 0;

    int result = connect(self.socketFD, (struct sockaddr *)&addr, sizeof(addr));
    if (result) {
        LOG_OC(LOG_ERROR, "Connect failed with error code [%d].", result);
        return NO;
    }
    LOG_OC(LOG_INFO, "Connect with kext successfully.");

    return YES;
}

/**
 * @brief 断开内核拓展连接
 */
- (void)destroyConnection {
    // 关闭套接字
    close(self.socketFD);
    _socketFD = -1;
    LOG_OC(LOG_INFO, "Disconnect with kext successfully.");
}