Netlink的简单例子

最新推荐文章于 2024-07-25 12:39:48 发布
最新推荐文章于 2024-07-25 12:39:48 发布
阅读量540 收藏
点赞数
分类专栏： 计算机网络 文章标签： c++
原文链接：https://www.dennisthink.com/2020/11/21/902/
版权
  • 采用Netlink进行内核与用户空间交互数据

参考：netlink学习笔记之NETLINK_INET_DIAG获取TCP连接状态(netstat) – 浮生笔记

比如获取连接状态

#if 0
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <asm/types.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#include <linux/inet_diag.h>
#include <netinet/tcp.h>

int main(int argc, char **argv)
{
    int fd;
    struct sockaddr_nl src_addr, dest_addr;
    struct
    {
        struct nlmsghdr nlh;
        struct inet_diag_req r;
    } req;
    struct inet_diag_msg *pkg;
    struct msghdr msg;
    char buf[8192];
    char src_ip[40];
    char dest_ip[40];
    struct iovec iov;

    if ((fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_INET_DIAG)) < 0)
        return -1;

    int ret;
    ret = fcntl(fd, F_SETFL, O_NONBLOCK);
    if (ret < 0) {
        fprintf(stderr, "Can't set socket flags");
        close(fd);
        return -1;
    }
    //src addr
    memset(&src_addr, 0, sizeof(struct sockaddr_nl));
    src_addr.nl_family = AF_NETLINK;
    src_addr.nl_pid = getpid();
    src_addr.nl_groups = 0;

    if (bind(fd, (struct sockaddr *)&src_addr, sizeof(struct sockaddr_nl)) < 0) {
        fprintf(stderr, "bind socket error %s\n", strerror(errno));
    }

    memset(&req, 0, sizeof(req));
    req.nlh.nlmsg_len = sizeof(req);
    req.nlh.nlmsg_type = TCPDIAG_GETSOCK;
    req.nlh.nlmsg_flags = NLM_F_MATCH | NLM_F_REQUEST | NLM_F_ROOT;
    // req.nlh.nlmsg_flags = NLM_F_REQUEST ;
    req.nlh.nlmsg_pid = 0;

    memset(&req.r, 0, sizeof(req.r));
    req.r.idiag_family = AF_INET;
    req.r.idiag_states = ((1 << TCP_CLOSING + 1) - 1); //states to dump

    //send msg to kernel
    iov.iov_base = &req;
    iov.iov_len = sizeof(req);

    //dest addr
    memset(&dest_addr, 0, sizeof(struct sockaddr_nl));
    dest_addr.nl_family = AF_NETLINK;
    dest_addr.nl_pid = 0;
    dest_addr.nl_groups = 0;

    msg.msg_name = (void *)&dest_addr;
    msg.msg_namelen = sizeof(dest_addr);
    msg.msg_iov = &iov;
    msg.msg_iovlen = 1;

    if (sendmsg(fd, &msg, 0) < 0) {
        printf("%s\n", strerror(errno));
        return -1;
    }
    //recv msg from kernel
    iov.iov_base = buf;
    iov.iov_len = sizeof(buf);

    while (1) {
        //printf("while1\n");
        int status;
        struct nlmsghdr *h;

        msg = (struct msghdr)
        {
            (void *)&dest_addr, sizeof(struct sockaddr_nl),
                &iov, 1, NULL, 0, 0
        };

        //length of recv data
        status = recvmsg(fd, &msg, 0);
        //status = recv(fd, buf, sizeof(buf), 0);
        printf("status = %d\n", status);
        if (status < 0) {
            if (errno == EINTR) {
                continue;
            }
            printf("errno = %d\n", errno);
            continue;
        }
        if (status == 0) {
            close(fd);
            printf("EOF\n");
            return 0;
        }

        h = (struct nlmsghdr *)buf;

        while (NLMSG_OK(h, status)) {
            //printf("while2\n");
            printf("nlmsg_type = %d\n",h->nlmsg_type );
            if (h->nlmsg_type == NLMSG_DONE) {
                close(fd);
                printf("NLMSG_DONE\n");
                return 0;
            }

            if (h->nlmsg_type == NLMSG_ERROR) {
                struct nlmsgerr *err;
                err = (struct nlmsgerr*)NLMSG_DATA(h);
                fprintf(stderr, "%d Error %d:%s\n", __LINE__, -(err->error), strerror(-(err->error)));
                close(fd);
                printf("NLMSG_ERROR\n");
                return 0;
            }

            pkg = (struct inet_diag_msg *)NLMSG_DATA(h);
            memset(src_ip, 0, sizeof(src_ip));
            memset(dest_ip, 0, sizeof(dest_ip));
            inet_ntop(pkg->idiag_family, pkg->id.idiag_src, src_ip, sizeof(src_ip));
            inet_ntop(pkg->idiag_family, pkg->id.idiag_dst, dest_ip, sizeof(dest_ip));
            printf("%-8s %4d %40s:%-6hu %40s:%-6hu\n", pkg->idiag_family == AF_INET ? "AF_INET" : "AF_INET6", pkg->idiag_state
                , src_ip, ntohs(pkg->id.idiag_sport), dest_ip, ntohs(pkg->id.idiag_dport));
            // get_tcp_state(pkg->idiag_state);
            h = NLMSG_NEXT(h, status);
            //printf("status = %d\n\n", status);
        }//while
    }//while
    close(fd);
    return 0;
}

#else
/**
 * @file NET_LINK_NET_STATE.c
 * @author dennisthink (https://www.dennisthink.com/)
 * @brief NETLINK方式获取 网络连接状态
 * @version 0.1
 * @date 2020-11-21
 * 
 * @copyright Copyright (c) 2020
 * 
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <asm/types.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#include <linux/inet_diag.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
 
/**
 * @brief 创建NetLinkDiag的socket
 * 
 * @return int > 0 创建成功
 *             - 1 创建失败
 */
int createNetLinkDiagSocket()
{
    int fd = 0;
    if ((fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_INET_DIAG)) < 0)
    {
        return -1;
    }    
    else
    {
        return fd;
    }
}
 
/**
 * @brief 设置socket为非阻塞模式
 * 
 * @param fd 被设置的socket描述符
 * @return int >= 0  -- 成功
 *             -1 -- 失败
 */
int setSocketOpt(int fd)
{
    int ret = 0;
    ret = fcntl(fd, F_SETFL, O_NONBLOCK);
    if (ret < 0)
    {
        fprintf(stderr, "Can't set socket flags");
        close(fd);
        return -1;
    }
    else
    {
        return ret;
    }   
}
 
 
/**
 * @brief 绑定socket到NetLink的地址
 * 
 * @param fd 待绑定的socket
 * @return int 0  --- 成功
 *             -1 --- 失败
 */
int bindSocketToNetLink(int fd)
{
    struct sockaddr_nl src_addr;
    {
        //src addr
        memset(&src_addr, 0, sizeof(struct sockaddr_nl));
        src_addr.nl_family = AF_NETLINK;
        src_addr.nl_pid = getpid();
        src_addr.nl_groups = 0;
    }
    if (bind(fd, (struct sockaddr *)&src_addr, sizeof(struct sockaddr_nl)) >=0 )
    {
        return 0;
    }
    else
    {
        return -1;
    }
}
 
 
 
/**
 * @brief 发送消息到内核
 * 
 * @param fd netlink的socket
 * @return int 0  -- 成功
 *             -1 -- 失败
 */
int sendMsgToNetLink(int fd)
{
    //4.1 初始化目标地址
    struct sockaddr_nl dest_addr;
    {
        memset(&dest_addr, 0, sizeof(struct sockaddr_nl));
        dest_addr.nl_family = AF_NETLINK;
        dest_addr.nl_pid = 0;
        dest_addr.nl_groups = 0;
    }
    //4.2 初始化请求的数据
    struct
    {
        struct nlmsghdr nlh;
        struct inet_diag_req r;
    } req;
    {
        memset(&req, 0, sizeof(req));
        req.nlh.nlmsg_len = sizeof(req);
        req.nlh.nlmsg_type = TCPDIAG_GETSOCK;
        req.nlh.nlmsg_flags = NLM_F_MATCH | NLM_F_REQUEST | NLM_F_ROOT;
        // req.nlh.nlmsg_flags = NLM_F_REQUEST ;
        req.nlh.nlmsg_pid = 0;
 
        memset(&req.r, 0, sizeof(req.r));
        req.r.idiag_family = AF_INET;
        req.r.idiag_states = ((1 << TCP_CLOSING + 1) - 1); //states to dump
    }
 
    //4.3 将请求数据绑定到消息上
    //4.3.1 将req数据绑定到iov上
    //注意:此处要定义一个数组,保存足够的buff，要不会出现 errno=105的错误
    struct iovec iov[2];
    char buff[4096]={0};
    {
        //send msg to kernel
        iov[0].iov_base = &req;
        iov[0].iov_len = sizeof(req);
 
        iov[1].iov_base = buff;
        iov[1].iov_len = sizeof(buff);
    }
 
 
    struct msghdr msgForSend;
    //4.3.2 将目标地址和请求数据绑定到msg上
    {
        msgForSend.msg_name = (void *)&dest_addr;
        msgForSend.msg_namelen = sizeof(dest_addr);
        msgForSend.msg_iov = iov;
        msgForSend.msg_iovlen = 2;
    }
    //4.4 发送消息
    if (sendmsg(fd, &msgForSend, 0) < 0)
    {
        return -1;
    }
    return 0;
}
 
 
/**
 * @brief 解析TCP的状态
 * 
 * @param nState tcp状态
 */
void parseTcpState(const int nState)
{
   switch(nState)
   {
       case TCP_ESTABLISHED:
       {
           printf("ESTABLISHED");
       }break;
       case TCP_SYN_SENT:
       {
           printf("SYN_SENT");
       }break;
       case TCP_SYN_RECV:
       {
           printf("SYN_RECV");
       }break;
       case TCP_FIN_WAIT1:
       {
           printf("FIN_WAIT1");
       }break;
       case TCP_FIN_WAIT2:
       {
           printf("FIN_WAIT2");
       }break;
       case TCP_TIME_WAIT:
       {
           printf("TIME_WAIT");
       }break;
       case TCP_CLOSE:
       {
           printf("CLOSE");
       }break;
       case TCP_CLOSE_WAIT:
       {
           printf("CLOSE_WAIT");
       }break;
       case TCP_LAST_ACK:
       {
           printf("LAST_ACK");
       }break;
       case TCP_CLOSING:
       {
           printf("CLOSING");
       }break;
       case TCP_LISTEN:
       {
           printf("LISTEN");
       }break;
       default:
       {
           printf("DEFAULT");
       }break;
   }
}
 
/**
 * @brief 解析收到的数据
 * 
 * @param buff 数据起始地址
 * @param status 数据的长度
 * @return int 默认返回0
 */
int parseRecvMsg(char *buff,int status)
{
    struct nlmsghdr * h = (struct nlmsghdr *)buff;
    while (NLMSG_OK(h, status))
    {
        if (h->nlmsg_type == NLMSG_DONE)
        {
            printf("NLMSG_DONE\n");
            return 0;
        }
 
        if (h->nlmsg_type == NLMSG_ERROR)
        {
            struct nlmsgerr *err;
            err = (struct nlmsgerr *)NLMSG_DATA(h);
            fprintf(stderr, "%d Error %d:%s\n", __LINE__, -(err->error), strerror(-(err->error)));
            return 0;
        }
        struct inet_diag_msg *pkg = (struct inet_diag_msg *)NLMSG_DATA(h);
        char src_ip[40];
        char dest_ip[40];
        memset(src_ip, 0, sizeof(src_ip));
        memset(dest_ip, 0, sizeof(dest_ip));
        inet_ntop(pkg->idiag_family, pkg->id.idiag_src, src_ip, sizeof(src_ip));
        inet_ntop(pkg->idiag_family, pkg->id.idiag_dst, dest_ip, sizeof(dest_ip));
        printf("%-8s %40s:%-6hu %40s:%-6hu", pkg->idiag_family == AF_INET ? "AF_INET" : "AF_INET6", src_ip, ntohs(pkg->id.idiag_sport), dest_ip, ntohs(pkg->id.idiag_dport));
        parseTcpState(pkg->idiag_state);
        printf("\n");
        h = NLMSG_NEXT(h, status);
    } //while
    return 0;
}
/**
 * @brief 从netlink接收消息
 * 
 * @param fd netlink套接字
 * @return int 默认返回0
 */
int recvMsgFromNetLink(int fd)
{
 
    char buf[8192]={0};
 
    //recv msg from kernel
    struct iovec iov;
 
    iov.iov_base = buf;
    iov.iov_len = sizeof(buf);
 
    struct sockaddr_nl destAddrForRecv;
    {
        memset(&destAddrForRecv, 0, sizeof(struct sockaddr_nl));
        destAddrForRecv.nl_family = AF_NETLINK;
        destAddrForRecv.nl_pid = 0;
        destAddrForRecv.nl_groups = 0;
    }
    struct msghdr msgForRecv;
    while (1)
    {
        msgForRecv.msg_name = (void *)(&destAddrForRecv);
        msgForRecv.msg_namelen = sizeof(destAddrForRecv);
        msgForRecv.msg_iov = &iov;
        msgForRecv.msg_iovlen  = 1;
 
        //length of recv data
        int status = recvmsg(fd, &msgForRecv, 0);
 
        if (status == 0)
        {
            return 0;
        }
        if(status > 0)
        {
            parseRecvMsg(buf,status);
            return 0;
        }
        usleep(1000);
    }//while
 
    return 0;
}
 
int main(int argc, char **argv)
{
    //创建socket
    int fd = createNetLinkDiagSocket();
    if(fd > 0)
    {
        printf("Create Socket Succeed\n");
    }
    else
    {
        printf("Create Socket Failed  ErrNo:%d  ErrMsg:%s\n",errno,strerror(errno));
        return -1;
    }
 
    //2. 设置socket选项
    if(setSocketOpt(fd) >= 0)
    {
        printf("Set socketOpt succeed \n");
    }
    else
    {
        printf("Set sockOpt faild  ErrNo:%d  ErrMsg:%s\n",errno,strerror(errno));
        return -1;
    }
 
    //3. 绑定socket
    if(bindSocketToNetLink(fd) >= 0)
    {
        printf("bind Socket To NetLink Succeed\n");
    }
    else
    {
        printf("bind Socket To NetLink faild  ErrNo:%d  ErrMsg:%s\n",errno,strerror(errno));
        return -1;
    }
 
    //4. 发送消息到内核
    if(sendMsgToNetLink(fd) >= 0)
    {
        printf("sendMsgToNetLink Succeed \n");
    }
    else
    {
        printf("sendMsgToNetLink Failed ErrNo:%d  ErrMsg:%s\n",errno,strerror(errno));
        return -1;
    }
 
    if(recvMsgFromNetLink(fd)>=0)
    {
        printf("recvMsgFromNetLink Succeed\n");
    }
    else
    {
       printf("recvMsgFromNetLink Failed ErrNo:%d  ErrMsg:%s\n",errno,strerror(errno));
    }
 
    close(fd);
    return 0;
}

#endif

L7256
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
af_netlink_netlink socket编程实例解析
weixin_39766867的博客
12-20 1314
开发和维护内核是一件很繁杂的工作，因此，只有那些最重要或者与系统性能息息相关的代码才将其安排在内核中。其它程序，比如GUI，管理以及控制部分的代码，一般都会作为用户态程序。在linux系统中，把系统的某个特性分割成在内核中和在用户空间中分别实现一部分的做法是很常见的(比如linux系统的防火墙就分成了内核态的Netfilter和用户态的iptables)。然而，内核程序与用户态的程序又是怎样行通讯...
netlink socket programming
02-24
下面是一个简单的例子，展示了如何使用`NETLINK_FILTER`协议： ```c struct nlmsghdr *nlh; struct nlmsghdr *nlnh; struct ipq_msg *ipqm; /* 构造Netlink消息 */ nlh = (struct nlmsghdr *)malloc(NLMSG_SPACE...
netlink简单实例
dolphin98629的专栏
10-30 1353
一、netlink简介 netlink协议是一种基于socket的IPC机制，可用于内核与用户空间进程、用户空间进程与用户空间进程通信，如图所示： netlink协议基于BSD socket和AF_NETLINK地址簇(address family)，使用32位的端口号寻址(以前称作PID)，每个netlink协议(或称作总线，man手册中则称之为netlink famil
(转)netlink简单实例
weixin_34061555的博客
04-05 106
2019独角兽企业重金招聘Python工程师标准>>> ...
推荐开源项目：libkcapi - Linux内核加密API用户空间接口库
gitblog_00097的博客
06-11 401
推荐开源项目：libkcapi - Linux内核加密API用户空间接口库 项目地址:https://gitcode.com/smuellerDD/libkcapi 1、项目介绍 libkcapi是一个强大的开源库，它为用户空间程序提供了直接访问Linux内核加密API的能力。无需考虑底层Netlink接口处理的复杂性，开发者可以通过简单易用的API实现各种加密操作。 2、项目技术分析 该库不实现...
Netlink与RTNetlink的简单使用
wjj970802的博客
03-27 1122
它是 Linux 系统中管理网络路由的标准接口，通过 RTNetlink，用户空间程序可以实现动态地添加、删除、修改路由表中的路由条目，以及监听路由表的变化。4）nlmsg_seq：消息序列号，用以将消息排队，有些类似TCP协议中的序号（不完全一样），但是netlink的这个字段是可选的，不强制使用；这些消息含有一个ifaddrmsg类型的结构，紧跟在后面的是一系列的rtattr结构。，表示的是路由项是如何产生的，可取的值如下，其中常见的是RTPROT_KERNEL和RTPROT_STAIC。
Linux: Netlink 简介
JiMoKuangXiangQu的专栏
04-27 632
Linux，网络，Netlink
内核通信之Netlink源码分析和实例分析
I want to know a little more.
08-05 875
前言 这几天在看 ipvs 相关代码的时候又遇到了 netlink 的事情，所以这两天花了点时间重新把 netlink 的事情梳理了一下。 什么是 netlink linux 内核一直存在的一个严重问题就是内核态和用户态的交互的问题，对于这个问题内核大佬们一直在研究各种方法，想让内核和用户态交互能够安全高效的进行。如系统调用，proc，sysfs等内存文件系统，但是这些方式一般都比较简单，只能在用户空间轮询访问内核的变化，内核的变化无法主动的推送出来。 而 netlink 的出现比较好的解决了这个问
linux netlink 用法,Linux下netlink编程示例
weixin_39551103的博客
05-13 452
在 Linux 2.4 版以后版本的内核中，几乎全部的中断过程与用户态进程的通信都是使用 netlink套接字实现的，同时还使用 netlink 实现了 ip queue 工具，但 ip queue的使用有其局限性，不能自由地用于各种中断过程。内核的帮助文档和其他一些 Linux 相关文章都没有对 netlink套接字在中断过程和用户空间通信的应用上作详细的说明，使得很多用户对此只有一个模糊的概念...
linux内核 netlink,Linux中与内核通信的Netlink机制（实例）
weixin_30293523的博客
04-29 824
Netlink在2.6版本的内核中变化也是很大的，在最新的2.6.37内核中，其定义已经改成下面这种形式，传递的参数已经达到6个。其中第一个参数和mutex参数都是最新添加的。Mutex也可以为空。这里主要是关于内核空间中的netlink函数的使用。extern struct sock *netlink_kernel_create(struct net *net,int unit,unsigned...
netlink
qq_45751806的博客
10-21 350
Netlink Socket是用以实现与通信的一种特殊的进程间通信(IPC) ，也是网络应用程序与内核通信的最常用的接口。Netlink 分为用户态与核心态两部分。本篇笔记包含最基本的操作，内核态只使用单播。
linux内核通信-netlink使用例子.pdf
11-19
6. **使用标准API**：用户空间使用标准的socket函数如`socket()`, `bind()`, `sendmsg()`, `recvmsg()`和`close()`，使得开发更加简单。 在用户空间使用Netlink时，首先需要包含`linux/netlink.h`和`sys/socket.h`...
netlink_example:使用netlink API安装IP地址或删除IP地址
03-21
这个例子中的netlink_example可能是对某个特定接口进行IP地址管理的一个简单实现。实际的代码会更复杂，需要处理错误，解析内核返回的响应，以及正确设置所有必要的属性和标志。libnl库提供了丰富的函数，如`nlattr_...
入门学习Linux常用必会60个命令实例详解doc/txt
06-09
入门学习Linux常用必会60个命令实例详解 Linux必学的60个命令 Linux提供了大量的命令，利用它可以有效地完成大量的工作，如磁盘操作、文件存取、目录操作、进程管理、文件权限设定等。所以，在Linux系统上工作离不...
genetlink_master例子代码
09-02
5. **示例应用程序**："demo-genetlink-master"可能包含一个简单的用户空间应用程序，演示如何创建和发送Genetlink消息，以及如何处理内核的响应。这个应用程序通常会展示如何注册到特定的Genetlink家族，以及如何...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1233
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++ primer plus 第16章string 类和标准模板库, 关联容器
最新发布
zhyjhacker的博客
07-25 680
C++ primer plus 第16章string 类和标准模板库, 关联容器。
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 282
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
Netlink MPI转以太网通讯模块配置指南
"Netlink应用步骤.pdf 是一份详细介绍Netlink应用流程的技术文档，主要关注通讯与网络领域，由北京高维精诚科技有限公司提供。文档中涵盖了Netlink（一款MPI转以太网通讯模块）的产品简介、特点以及配置步骤，旨在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值