linux内核与用户空间通信机制（二）——Netlink的使用

最新推荐文章于 2024-03-01 11:00:09 发布
最新推荐文章于 2024-03-01 11:00:09 发布
阅读量357 收藏 3
点赞数
分类专栏： linux知识总结 文章标签： 内核 网络 linux netlink
原文链接：https://www.cnblogs.com/wenqiang/p/6306727.html
版权

Netlink的使用

一、建立Netlink会话的过程

在这里插入图片描述

二、Netlink常用数据结构及函数

在这里插入图片描述

1. netlink 内核数据结构、常用宏及函数：
netlink消息类型：

#define NETLINK_ROUTE       0   /* Routing/device hook              */
#define NETLINK_UNUSED      1   /* Unused number                */
#define NETLINK_USERSOCK    2   /* Reserved for user mode socket protocols  */
#define NETLINK_FIREWALL    3   /* Unused number, formerly ip_queue     */
#define NETLINK_SOCK_DIAG   4   /* socket monitoring                */
#define NETLINK_NFLOG       5   /* netfilter/iptables ULOG */
#define NETLINK_XFRM        6   /* ipsec */
#define NETLINK_SELINUX     7   /* SELinux event notifications */
#define NETLINK_ISCSI       8   /* Open-iSCSI */
#define NETLINK_AUDIT       9   /* auditing */
#define NETLINK_FIB_LOOKUP  10
#define NETLINK_CONNECTOR   11
#define NETLINK_NETFILTER   12  /* netfilter subsystem */
#define NETLINK_IP6_FW      13
#define NETLINK_DNRTMSG     14  /* DECnet routing messages */
#define NETLINK_KOBJECT_UEVENT  15  /* Kernel messages to userspace */
#define NETLINK_GENERIC     16
/* leave room for NETLINK_DM (DM Events) */
#define NETLINK_SCSITRANSPORT   18  /* SCSI Transports */
#define NETLINK_ECRYPTFS    19
#define NETLINK_RDMA        20
#define NETLINK_CRYPTO      21  /* Crypto layer */

#define NETLINK_INET_DIAG   NETLINK_SOCK_DIAG

#define MAX_LINKS 32

netlink常用宏：

#define NLMSG_ALIGNTO   4U
/* 宏NLMSG_ALIGN(len)用于得到不小于len且字节对齐的最小数值 */
#define NLMSG_ALIGN(len) ( ((len)+NLMSG_ALIGNTO-1) & ~(NLMSG_ALIGNTO-1) )

/* Netlink 头部长度 */
#define NLMSG_HDRLEN     ((int) NLMSG_ALIGN(sizeof(struct nlmsghdr)))

/* 计算消息数据len的真实消息长度（消息体 +　消息头）*/
#define NLMSG_LENGTH(len) ((len) + NLMSG_HDRLEN)

/* 宏NLMSG_SPACE(len)返回不小于NLMSG_LENGTH(len)且字节对齐的最小数值 */
#define NLMSG_SPACE(len) NLMSG_ALIGN(NLMSG_LENGTH(len))

/* 宏NLMSG_DATA(nlh)用于取得消息的数据部分的首地址，设置和读取消息数据部分时需要使用该宏 */
#define NLMSG_DATA(nlh)  ((void*)(((char*)nlh) + NLMSG_LENGTH(0)))

/* 宏NLMSG_NEXT(nlh,len)用于得到下一个消息的首地址, 同时len 变为剩余消息的长度 */
#define NLMSG_NEXT(nlh,len)  ((len) -= NLMSG_ALIGN((nlh)->nlmsg_len), \
                  (struct nlmsghdr*)(((char*)(nlh)) + NLMSG_ALIGN((nlh)->nlmsg_len)))

/* 判断消息是否 >len */
#define NLMSG_OK(nlh,len) ((len) >= (int)sizeof(struct nlmsghdr) && \
               (nlh)->nlmsg_len >= sizeof(struct nlmsghdr) && \
               (nlh)->nlmsg_len <= (len))

/* NLMSG_PAYLOAD(nlh,len) 用于返回payload的长度*/
#define NLMSG_PAYLOAD(nlh,len) ((nlh)->nlmsg_len - NLMSG_SPACE((len)))

netlink 内核常用函数：
netlink_kernel_create内核函数用于创建 内核socket用与户态通信

static inline struct sock *
netlink_kernel_create(struct net *net, int unit, struct netlink_kernel_cfg *cfg)
/* net: net指向所在的网络命名空间, 一般默认传入的是&init_net(不需要定义);  定义在net_namespace.c(extern struct net init_net);
   unit：netlink协议类型
   cfg： cfg存放的是netlink内核配置参数（如下）
*/

/* optional Netlink kernel configuration parameters */
struct netlink_kernel_cfg {
    unsigned int    groups;
    unsigned int    flags;
    void        (*input)(struct sk_buff *skb); /* input 回调函数 */
    struct mutex    *cb_mutex;
    void        (*bind)(int group);
    bool        (*compare)(struct net *net, struct sock *sk);
};

单播netlink_unicast() 和 多播netlink_broadcast()

/* 来发送单播消息 */
extern int netlink_unicast(struct sock *ssk, struct sk_buff *skb, __u32 portid, int nonblock);
/* ssk: netlink socket
   skb: skb buff 指针
   portid： 通信的端口号
   nonblock：表示该函数是否为非阻塞，如果为1，该函数将在没有接收缓存可利用时立即返回，而如果为0，该函数在没有接收缓存可利用 定时睡眠
*/

/* 用来发送多播消息 */
extern int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, __u32 portid,
                 __u32 group, gfp_t allocation);
/* ssk: 同上（对应netlink_kernel_create 返回值）、
   skb: 内核skb buff
   portid： 端口id
   group: 是所有目标多播组对应掩码的"OR"操作的合值。
   allocation: 指定内核内存分配方式，通常GFP_ATOMIC用于中断上下文，而GFP_KERNEL用于其他场合。
                这个参数的存在是因为该API可能需要分配一个或多个缓冲区来对多播消息进行clone
*/

2.用户态数据结构

用户态应用使用标准的 socket API有（sendto()），recvfrom()； sendmsg(), recvmsg()）

struct sockaddr_nl结构：

1 struct sockaddr_nl {
2     __kernel_sa_family_t    nl_family;  /* AF_NETLINK （跟AF_INET对应）*/
3     unsigned short  nl_pad;     /* zero */
4     __u32       nl_pid;     /* port ID  （通信端口号）*/
5     __u32       nl_groups;  /* multicast groups mask */
6 };

struct nlmsghd 结构：

/* struct nlmsghd 是netlink消息头*/
struct nlmsghdr {
    __u32       nlmsg_len;  /* Length of message including header */
    __u16       nlmsg_type; /* Message content */
    __u16       nlmsg_flags;    /* Additional flags */
    __u32       nlmsg_seq;  /* Sequence number */
    __u32       nlmsg_pid;  /* Sending process port ID */
};

（1）nlmsg_len：整个netlink消息的长度（包含消息头）;
（2）nlmsg_type：消息状态，内核在include/uapi/linux/netlink.h中定义了以下4种通用的消息类型，它们分别是：

#define NLMSG_NOOP      0x1 /* Nothing.     */
#define NLMSG_ERROR     0x2 /* Error        */
#define NLMSG_DONE      0x3 /* End of a dump    */
#define NLMSG_OVERRUN       0x4 /* Data lost        */

#define NLMSG_MIN_TYPE      0x10    /* < 0x10: reserved control messages */

/*NLMSG_NOOP：不执行任何动作，必须将该消息丢弃；
NLMSG_ERROR：消息发生错误；
NLMSG_DONE：标识分组消息的末尾；
NLMSG_OVERRUN：缓冲区溢出，表示某些消息已经丢失。
NLMSG_MIN_TYPEK：预留 */

(3）nlmsg_flags：消息标记，它们用以表示消息的类型，如下

/* Flags values */

#define NLM_F_REQUEST       1   /* It is request message.   */
#define NLM_F_MULTI     2   /* Multipart message, terminated by NLMSG_DONE */
#define NLM_F_ACK       4   /* Reply with ack, with zero or error code */
#define NLM_F_ECHO      8   /* Echo this request        */
#define NLM_F_DUMP_INTR     16  /* Dump was inconsistent due to sequence change */

/* Modifiers to GET request */
#define NLM_F_ROOT  0x100   /* specify tree root    */
#define NLM_F_MATCH 0x200   /* return all matching  */
#define NLM_F_ATOMIC    0x400   /* atomic GET       */
#define NLM_F_DUMP  (NLM_F_ROOT|NLM_F_MATCH)

/* Modifiers to NEW request */
#define NLM_F_REPLACE   0x100   /* Override existing        */
#define NLM_F_EXCL  0x200   /* Do not touch, if it exists   */
#define NLM_F_CREATE    0x400   /* Create, if it does not exist */
#define NLM_F_APPEND    0x800   /* Add to end of list       */

(4）nlmsg_seq：消息序列号，用以将消息排队，有些类似TCP协议中的序号（不完全一样），但是netlink的这个字段是可选的，不强制使用；
(5）nlmsg_pid：发送端口的ID号，对于内核来说该值就是0，对于用户进程来说就是其socket所绑定的ID号。

struct msghdr 结构体

struct iovec {                    /* Scatter/gather array items */
     void  *iov_base;              /* Starting address */
     size_t iov_len;               /* Number of bytes to transfer */
 };
  /* iov_base: iov_base指向数据包缓冲区，即参数buff，iov_len是buff的长度。msghdr中允许一次传递多个buff，
    以数组的形式组织在 msg_iov中，msg_iovlen就记录数组的长度 （即有多少个buff）
  */
 struct msghdr {
     void         *msg_name;       /* optional address */
     socklen_t     msg_namelen;    /* size of address */
     struct iovec *msg_iov;        /* scatter/gather array */
     size_t        msg_iovlen;     /* # elements in msg_iov */
     void         *msg_control;    /* ancillary data, see below */
     size_t        msg_controllen; /* ancillary data buffer len */
     int           msg_flags;      /* flags on received message */
 };
 /* msg_name： 数据的目的地址，网络包指向sockaddr_in, netlink则指向sockaddr_nl;
    msg_namelen: msg_name 所代表的地址长度
    msg_iov: 指向的是缓冲区数组
    msg_iovlen: 缓冲区数组长度
    msg_control: 辅助数据，控制信息(发送任何的控制信息)
    msg_controllen: 辅助信息长度
    msg_flags: 消息标识
 */

三、netlink实例

(1）用户态程序 （sendto()， recvfrom()）

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <string.h>
#include <linux/netlink.h>
#include <stdint.h>
#include <unistd.h>
#include <errno.h>

#define NETLINK_TEST    30
#define MSG_LEN            125
#define MAX_PLOAD        125

typedef struct _user_msg_info
{
    struct nlmsghdr hdr;
    char  msg[MSG_LEN];
} user_msg_info;

int main(int argc, char **argv)
{
    int skfd;
    int ret;
    user_msg_info u_info;
    socklen_t len;
    struct nlmsghdr *nlh = NULL;
    struct sockaddr_nl saddr, daddr;
    char *umsg = "hello netlink!!";

    /* 创建NETLINK socket */
    skfd = socket(AF_NETLINK, SOCK_RAW, NETLINK_TEST);
    if(skfd == -1)
    {
        perror("create socket error\n");
        return -1;
    }

    memset(&saddr, 0, sizeof(saddr));
    saddr.nl_family = AF_NETLINK; //AF_NETLINK
    
    saddr.nl_pid = 100;  //如果希望内核处理消息或多播消息，就把该字段设置为 0，否则设置为处理消息的进程 ID
    saddr.nl_groups = 0;//用于指定多播组，bind 函数用于把调用进程加入到该字段指定的多播组，如果设置为 0，表示调用者不加入任何多播组
    
    /* 对于一个进程的多个线程使用 netlink socket 的情况，pthread_self() << 16 | getpid();
    
       字段 nl_pid 实际上未必是进程 ID,它只是用于区分不同的接收者或发送者的一个标识
       
       如果字段 nl_pid 设置为 0，表示消息接收者为内核或多播组，如果 nl_groups为 0，表示该消息为单播消息，否则表示多播消息
       
       当saddr.nl_pid = getpid();时，需要将pid值传给内核态（例如通过ioctl传递），此处为了方便设为固定值100
    */
    if(bind(skfd, (struct sockaddr *)&saddr, sizeof(saddr)) != 0)
    {
        perror("bind() error\n");
        close(skfd);
        return -1;
    }

	//配置目的sockaddr_nl
    memset(&daddr, 0, sizeof(daddr));
    daddr.nl_family = AF_NETLINK;
    daddr.nl_pid = 0; // to kernel
    daddr.nl_groups = 0;

	//定义消息结构体变量
    nlh = (struct nlmsghdr *)malloc(NLMSG_SPACE(MAX_PLOAD));
    memset(nlh, 0, sizeof(struct nlmsghdr));
    nlh->nlmsg_len = NLMSG_SPACE(MAX_PLOAD);
    nlh->nlmsg_flags = 0;
    nlh->nlmsg_type = 0;
    nlh->nlmsg_seq = 0;
    nlh->nlmsg_pid = saddr.nl_pid; //self port

    memcpy(NLMSG_DATA(nlh), umsg, strlen(umsg)); //附上要发送的消息
    ret = sendto(skfd, nlh, nlh->nlmsg_len, 0, (struct sockaddr *)&daddr, sizeof(struct sockaddr_nl));
    if(!ret)
    {
        perror("sendto error\n");
        close(skfd);
        exit(-1);
    }
    printf("send kernel:%s\n", umsg);

    memset(&u_info, 0, sizeof(u_info));
    len = sizeof(struct sockaddr_nl);
    ret = recvfrom(skfd, &u_info, sizeof(user_msg_info), 0, (struct sockaddr *)&daddr, &len);
    if(!ret)
    {
        perror("recv form kernel error\n");
        close(skfd);
        exit(-1);
    }

    printf("from kernel:%s\n", u_info.msg);
    close(skfd);

    free((void *)nlh);
    return 0;
}

Netlink 内核模块代码：

/****************************************
* Author: zhangwj
* Date: 2017-01-19
* Filename: netlink_test.c
* Descript: netlink of kernel
* Kernel: 3.10.0-327.22.2.el7.x86_64
* Warning:
******************************************/

#include <linux/init.h>
#include <linux/module.h>
#include <linux/types.h>
#include <net/sock.h>
#include <linux/netlink.h>

#define NETLINK_TEST     30
#define MSG_LEN            125
#define USER_PORT        100

MODULE_LICENSE("GPL");
MODULE_AUTHOR("zhangwj");
MODULE_DESCRIPTION("netlink example");

struct sock *nlsk = NULL;
extern struct net init_net;

int send_usrmsg(char *pbuf, uint16_t len)
{
    struct sk_buff *nl_skb;
    struct nlmsghdr *nlh;

    int ret;

    /* 创建sk_buff 空间 */
    nl_skb = nlmsg_new(len, GFP_ATOMIC);
    if(!nl_skb)
    {
        printk("netlink alloc failure\n");
        return -1;
    }

    /* 设置netlink消息头部 */
    nlh = nlmsg_put(nl_skb, 0, 0, NETLINK_TEST, len, 0);
    if(nlh == NULL)
    {
        printk("nlmsg_put failaure \n");
        nlmsg_free(nl_skb);
        return -1;
    }

    /* 拷贝数据发送 */
    memcpy(nlmsg_data(nlh), pbuf, len);
    ret = netlink_unicast(nlsk, nl_skb, USER_PORT, MSG_DONTWAIT);

    return ret;
}

static void netlink_rcv_msg(struct sk_buff *skb)
{
    struct nlmsghdr *nlh = NULL;
    char *umsg = NULL;
    char *kmsg = "hello users!!!";

    if(skb->len >= nlmsg_total_size(0))
    {
        nlh = nlmsg_hdr(skb);
        umsg = NLMSG_DATA(nlh);
        if(umsg)
        {
            printk("kernel recv from user: %s\n", umsg);
            send_usrmsg(kmsg, strlen(kmsg));
        }
    }
}

struct netlink_kernel_cfg cfg = {
        .input  = netlink_rcv_msg, /* set recv callback */
};

int test_netlink_init(void)
{
    /* create netlink socket */
    nlsk = (struct sock *)netlink_kernel_create(&init_net, NETLINK_TEST, &cfg);
    if(nlsk == NULL)
    {
        printk("netlink_kernel_create error !\n");
        return -1;
    }
    printk("test_netlink_init\n");

    return 0;
}

void test_netlink_exit(void)
{
    if (nlsk){
        netlink_kernel_release(nlsk); /* release ..*/
        nlsk = NULL;
    }
    printk("test_netlink_exit!\n");
}

module_init(test_netlink_init);
module_exit(test_netlink_exit);

Makeflie：

#
#Desgin of Netlink
#

MODULE_NAME :=netlink_test
obj-m :=$(MODULE_NAME).o

KERNELDIR ?= /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)

all:
    $(MAKE) -C $(KERNELDIR) M=$(PWD)

clean:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) clean

运行结果：

首先将编译出来的Netlink内核模块插入到系统当中（insmod netlink_test.ko）可以看到如下：

1 [root@localhost nt_2nd]# insmod netlink_test.ko 
2 [root@localhost nt_2nd]# dmesg
3 [25024.276345] test_netlink_init

接着运行应用程序：./a.out

[root@localhost nt_2nd]# ./a.out
send kernel:hello netlink!!
from kernel:hello users!!!
[root@localhost nt_2nd]# dmesg
[25024.276345] test_netlink_init
[25117.548350] kernel recv from user: hello netlink!!
[root@localhost nt_2nd]#
JCfyw
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
内核和用户空间通信—netlink源码
05-12
一、imp2源码 整个源码包含三个文件：imp2_k.c, imp2_u.c和imp2.h. 其中imp2_k.c为内核模块的源代码，imp2_u.c为应用程序，即测试代码，imp2.h为两个源文件都需要引用的头文件。其整体的功能是：注册一种新的netlink协议，并注册一个新的NF hook函数。当有ping包发往当前主机或者经过当前主机转发时，内核向用户发送ping包的源IP和目的IP。各个文件的简单分析见下文。 1. imp2.h 该文件主要是定义了一种新的Netlink协议类型NL_IMP2（31）。新的协议类型的选值不能和当前内核中已经定义的netlink协议类型重复。定义了基于该协议类型的消息类型，内核根据接收到消息的不同类型，进行不同的处理：IMP2_U_PID和IMP2_CLOSE分别为请求和关闭。IMP2_K_MSG代表内核空间发送的消息。 该头文件的源码如下： 2. imp2_k.c 该程序为内核模块程序。其完成的功能如下： (1)创建一种新的Netlink协议NL_IMP2，并注册该协议的回调函数kernel_receive。但用户空间通过建立且协议类型为NL_IMP2的socket套接字并调用sendto，sendmsg函数发送数据时，传送到内核空间的数据由kernel_receive进行处理。该函数主要是记录用户进程的ID，用于随后发送数据的时候指定目的。 (2)在Netfilter的hook点NF_IP_PRE_ROUTING注册hook函数get_icmp，对经过该hook点的ping包进行处理。get_icmp首先判断是否是ping包，如果不是，直接Accept。如果是，则记录该包的源IP和目的IP，然后调用send_to_user，将记录的信息发送给kernel_recieve函数中记录的用户进程ID。 该文件的源码如下： 3. imp2_u.c 该程序为用户空间的测试程序。该程序包括以下功能： （1）生成NL_IMP2协议的socket.然后通过调用sendto发送IMP2_U_PID类型的请求信息给内核。然后等待接受内核发回的信息。记住：仅当有ping包经过内核的NF时，内核才会向用户进程发送信息。 （2）当用户进程通过Ctrl+C来结束该程序时，调用信号处理函数sig_int，向内核发送IMP2_CLOSE的消息，结束socket。 该文件的源码如下： 二、编译和测试 1. 整个源文件编译的Makefile如下： all: gcc -O2 -DMODULE -D__KERNEL__ -W -Wstrict-prototypes -Wmissing-prototypes -isystem /lib/modules/`uname -r`/build/include -c -o imp2_k.o imp2_k.c gcc imp2_u.c -o imp2_u install: insmod imp2_k.o uninstall: rmmod imp2_k clean: rm -f imp2_k.o imp2_u 2. 加载内核模块，并执行测试程序。 #make install #./imp2_u 当没有ping包时，终端一直处于等待输出状态。通过另一台主机(192.168.1.100)向当前主机(192.168.1.101)发送ping包，则终端已经有输出： #./imp2_u [root@localhost imp2]# ./imp2_u src: 192.168.1.100, dest: 192.168.1.101 src: 192.168.1.100, dest: 192.168.1.101 src: 192.168.1.100, dest: 192.168.1.101 src: 192.168.1.100, dest: 192.168.1.101
linux下用户程序同内核通信详解（netlink机制）
09-15
总的来说，Netlink机制为Linux系统提供了强大的内核与用户空间通信能力，它简化了系统的复杂性，增强了可扩展性和性能。无论是开发驱动程序、管理系统资源，还是实现高级网络服务，Netlink都是一个值得考虑的通信...
Netlink的简介及使用方法
hnlgzb的专栏
09-27 5514
Netlink套接字是用以实现用户进程与内核进程通信的一种特殊的进程间通信(IPC) ,也是网络应用程序与内核通信的最常用的接口。 一：什么是Netlink通信机制 Netlink是linux提供的用于内核和用户态进程之间的通信方式。 但是注意虽然Netlink主要用于用户空间和内核空间的通信，但是也能用于用户空间的两个进程通信。只是进程间通信有其他很多 方式，一般不用Netlink。除非需要用到Netlink的广播特性时。 1、Netlink socket的作用： 　　Netlink ..
linux link 函数,Linux Netlink基本使用
weixin_39623805的博客
05-03 289
好了，有了这个例子我们就大概知道用户态怎么使用Netlink了，至于我们没有用到的nl_groups等其他信息后面讲到再说，下面看下内核是怎么处理Netlink的。4. 内核 Netlink api4.1创建 netlink socketstruct sock *netlink_kernel_create(struct net *net,int unit,unsigned int groups,v...
NetLink详解
lw_yang的博客
10-22 5046
Netlink 是一种特殊的 socket，它是 Linux 所特有的，类似于 BSD 中的AF_ROUTE 但又远比它的功能强大，目前在最新的 Linux 内核（2.6.14）中使用netlink 进行应用与内核通信的应用很多，包括：路由 daemon（NETLINK_ROUTE），1-wire 子系统（NETLINK_W1），用户态 socket 协议（NETLINK_USER...
Linux Kernel : 内核与用户层通信之netlink
llanlianggui的博客
04-11 447
(本章基于：Linux-4.4.0-37) 内核与用户空间通信有很多种通信方式，netlink是其中一种，其余的还有/proc、ioctl、sockopt、共享内存等等。netlink的特点是异步全双工。 netlink使用32位端口寻址，称为pid（与进程号没有关系），其中内核的pid地址为0,。netlink主要特性如下： 1 支持全双工、异步通信(当然同步也支持) 2 ...
Linux内核与用户空间通信机制研究.pdf
09-06
Linux内核与用户空间通信机制研究 Linux操作系统采用的单内核架构具有简单、高效、安全的优点。Linux各子系统包含在内核中，而系统配置及管理工具运行于用户空间。开发人员需要采用一种合适的在内核与用户空间之间...
Netlink实现Linux内核与用户空间通信
01-09
Linux内核与用户空间通信的方式目前主要有9种，分别是内核启动参数、模块参数与 sysfs、sysctl、系统调用、netlink、procfs、seq_file、debugfs和relayfs。Netlink是一种特殊的文件描述符（套结字），为2.6.14及更高...
linux内核态与用户态通信-netlink实例解析
07-24
Netlink是一种轻量级的、安全的通信机制，它使用标准的套接字API，允许用户空间程序通过内核提供的特定协议与内核进行通信。Netlink支持多对多的消息传递，且能提供身份验证和错误检测。 四、Netlink工作原理 1. ...
详解Linux用户态与内核态通信的几种方式
01-10
我们平常在写代码时，一般是在用户空间，通过系统调用函数来访问内核空间，这是最常用的一种用户态和内核态通信的方式。（关于 Linux 用户态和内核态可以参考 xx） 除此之外，还有以下四种方式： procfs(/proc) ...
一文带你走进Linux内核之XFRM框架
m0_73494896的博客
09-02 1439
XFRM的正确读音是transform(转换), 这表示内核协议栈收到的IPsec报文需要经过转换才能还原为原始报文；同样地，要发送的原始报文也需要转换为IPsec报文才能发送出去。Psec（Internet协议安全）应该很多人都听过，IPsec是一组协议，他们通过对通信会话中的每个数据包进行身份验证和加密，以确保IP流量的安全。XFRM框架是IPsec的“基础设施”，IPsec通过XFRM框架实现的。XFRM源自USAGI项目，该项目旨在提供适用于生产环境的IPv6和IPsec协议栈。
netlink原理及应用
最新发布
congchp的博客
03-01 1853
netlink是一种基于网络的通信机制，允许内核内部、内核与用户态应用之间甚至用户态应用之间进行通信；netlink的主要作用是内核与用户态之间通信；它的思想是，基于BSD的socket使用网络框架在内核和用户态之间进行通信；如何在中新增netlink协议？参考nl80211模块初始化时，通过注册通用netlink协议族，将命令以及处理函数进行注册；int err;
netlink机制
weixin_34363171的博客
04-08 258
netlink是一种基于网络的机制，允许在内核内部以及内核与用户层之间进行通信。最早在内核2.2引入，旨在替代笨拙的IOCTL，IOCTL不能从内核向用户空间发送异步消息，而且必须定义IOCTL号。 Netlink协议定义在RFC3549中。以前是可以编译成模块，现在直接集成到内核了。与profs和sysfs相比，有一些优势如下： 不需要轮询；系统调...
2020-04-28
qq_41224661的博客
04-28 575
libnl解析消息 nlmsg_hdr是从nl_msg结构体得到nlmsghdr。 nlmsg_data是得到消息的payload的开始地址。 两个函数都定义在libnl源码的lib/msg.c中。
linux的netlink机制
lailaiquququ11的博客
08-19 698
linux下从内核空间到用户空间的异步通信可以使用到netLink，像设备的路由等信息都是通过该机制实现。 以下是一个netlink实例的链接： https://blog.csdn.net/qq_29214249/article/details/74909160
内核与用户空间的通信实现—netlink
ljl113的博客
09-25 2581
netlink的简单驱动和应用程序实现
Netlink中常用宏定义
Be the best myself
02-04 9962
在linux/netlink.h中定义了一些方便对消息进行处理的宏，这些宏包括：#define NLMSG_ALIGNTO 4 #define NLMSG_ALIGN(len) ( ((len)+NLMSG_ALIGNTO-1) & ~(NLMSG_ALIGNTO-1) ) 宏NLMSG_ALIGN(len)用于得到不小于len且字节对齐的最小数值。
Linux Kernel 学习笔记9：内核与用户层通信之netlink
热门推荐
stone8761的专栏
05-27 1万+
(本章基于：Linux-4.4.0-37) 内核与用户空间通信有很多种通信方式，netlink是其中一种，其余的还有/proc、ioctl、sockopt、共享内存等等。netlink的特点是异步全双工。 netlink使用32位端口寻址，称为pid（与进程号没有关系），其中内核的pid地址为0,。netlink主要特性如下： ① 支持全双工、异步通信(当然同步也支持) ② 用
Linux用户空间与内核通信：Netlink与字符设备解析
Netlink是一种安全、高效且灵活的用户空间与内核空间通信机制。用户态应用程序通过标准的socket API来使用Netlink，包括`socket()`, `bind()`, `sendmsg()`, `recvmsg()` 和 `close()` 函数。使用Netlink时，需包含`...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值