乐于分享
好东西不私藏
当前位置：夜雨聆风 > 技术教程 > 软件教程 > 跨平台底层网络库libdnet源码分析系列(七)

跨平台底层网络库libdnet源码分析系列(七)

当前时间： 2026-03-24 13:09:50 更新时间： 2026-03-24 分类：软件教程 评论(0)

跨平台底层网络库libdnet源码分析系列(七)

官网：http://securitytech.cc

源码分析mettle后门工具学习 所使用的依赖库

MAC地址处理深入分析

目录

  1. MAC地址基础概念
  2. libdnet以太网接口设计
  3. Linux平台实现
  4. macOS/BSD平台实现
  5. Solaris平台实现
  6. HP-UX平台实现
  7. AIX平台实现
  8. Windows平台实现
  9. 跨平台对比分析
  10. 实际应用示例
  11. 常见问题与解决方案

1. MAC地址基础概念

1.1 MAC地址简介

MAC地址（Media Access Control Address）是网络设备的物理地址，用于数据链路层的设备标识。MAC地址具有以下特点：

  • 长度：48位（6字节）
  • 格式：十六进制表示，如 00:11:22:33:44:55
  • 唯一性：理论上全球唯一
  • 可变性：大多数设备可以修改

1.2 MAC地址结构

  1. // include/dnet/eth.h:25-27
  2. typedefstruct eth_addr {
  3. uint8_t data[ETH_ADDR_LEN];// 6字节数组
  4. }eth_addr_t;

1.3 MAC地址分类

1.3.1 单播地址（Unicast）

  • 第一个字节的最低位为0
  • 例如： 00:11:22:33:44:55
  • 用于点对点通信

1.3.2 多播地址（Multicast）

  • 第一个字节的最低位为1
  • 例如： 01:00:5e:00:00:01
  • 用于组播通信

1.3.3 广播地址（Broadcast）

  • 所有48位都为1
  • ff:ff:ff:ff:ff:ff
  • 用于广播通信

判断宏：

  1. // include/dnet/eth.h:70
  2. #define ETH_IS_MULTICAST(ea)(*(ea)&0x01)// 检查是否为多播/广播

1.4 以太网帧结构

  1. // include/dnet/eth.h:29-33
  2. struct eth_hdr {
  3. eth_addr_t eth_dst;// 目标MAC地址（6字节）
  4. eth_addr_t eth_src;// 源MAC地址（6字节）
  5. uint16_t eth_type;// 以太网类型/长度（2字节）
  6. };

以太网帧长度：

  • 最小帧长：64字节（包含4字节CRC）
  • 最大帧长：1518字节（包含4字节CRC）
  • MTU：1500字节（不包括以太网头和CRC）

常量定义：

  1. // include/dnet/eth.h:13-23
  2. #define ETH_ADDR_LEN     6// MAC地址长度
  3. #define ETH_ADDR_BITS    48// MAC地址位数
  4. #define ETH_TYPE_LEN     2// 以太网类型字段长度
  5. #define ETH_CRC_LEN      4// CRC校验长度
  6. #define ETH_HDR_LEN      14// 以太网头长度
  7. #define ETH_LEN_MIN      64// 最小帧长
  8. #define ETH_LEN_MAX      1518// 最大帧长
  9. #define ETH_MTU          1500// 最大传输单元

1.5 以太网类型（EtherType）

常见的以太网类型值：

EtherType
名称
说明
0x0200
PUP
Xerox PUP协议
0x0800
IP
IPv4协议
0x0806
ARP
地址解析协议
0x8035
RARP
反向地址解析协议
0x8100
802.1Q
VLAN标签
0x86DD
IPv6
IPv6协议
0x8847
MPLS
MPLS单播
0x8848
MPLS MCAST
MPLS组播
0x8863
PPPOEDISC
PPPoE发现阶段
0x8864
PPPOE
PPPoE会话阶段
0x88a8
802.1ad
双标签VLAN
0x9000
Loopback
回环测试
0x9100/9200/9300
802.1ad
Cisco双标签VLAN

1.6 VLAN标签结构

  1. // include/dnet/eth.h:54-61
  2. struct eth_8021q_hdr {
  3. uint16_t priority_c_vid;// 优先级|VLAN ID（TCI）
  4. uint16_t len_eth_type;// 长度或类型
  5. };
  7. #define ETH_8021Q_PRIMASK   0x0007// 优先级掩码（3位）
  8. #define ETH_8021Q_CFIMASK   0x0001// 规范格式标识符（1位）
  9. #define ETH_8021Q_VIDMASK   0x0fff// VLAN ID掩码（12位）

VLAN类型判断：

  1. // include/dnet/eth.h:63-68
  2. #define ETH_TYPE_IS_VLAN(type) \
  3. (((type)== ETH_TYPE_8021Q)|| \
  4. ((type)== ETH_TYPE_8021ad_0)|| \
  5. ((type)== ETH_TYPE_8021ad_1)|| \
  6. ((type)== ETH_TYPE_8021ad_2)|| \
  7. ((type)== ETH_TYPE_8021ad_3))

2. libdnet以太网接口设计

2.1 核心API接口

  1. // include/dnet/eth.h:84-93
  2. eth_t*eth_open(constchar*device);// 打开以太网设备
  3. int eth_get(eth_t*e,eth_addr_t*ea);// 获取MAC地址
  4. int eth_set(eth_t*e,consteth_addr_t*ea);// 设置MAC地址
  5. ssize_t eth_send(eth_t*e,constvoid*buf,size_t len);// 发送以太网帧
  6. eth_t*eth_close(eth_t*e);// 关闭以太网设备
  8. char*eth_ntop(consteth_addr_t*eth,char*dst,size_t len);// MAC转字符串
  9. int eth_pton(constchar*src,eth_addr_t*dst);// 字符串转MAC
  10. char*eth_ntoa(consteth_addr_t*eth);// MAC转字符串（简写）

2.2 以太网帧打包宏

  1. // include/dnet/eth.h:74-79
  2. #define eth_pack_hdr(h, dst, src, type)do{           \
  3. struct eth_hdr *eth_pack_p =(struct eth_hdr *)(h);   \
  4.     memcpy(&eth_pack_p->eth_dst,&(dst), ETH_ADDR_LEN);  \
  5.     memcpy(&eth_pack_p->eth_src,&(src), ETH_ADDR_LEN);  \
  6.     eth_pack_p->eth_type = htons(type);                 \
  7. }while(0)

使用示例：

  1. eth_addr_t dst ={0xff,0xff,0xff,0xff,0xff,0xff};// 广播
  2. eth_addr_t src ={0x00,0x11,0x22,0x33,0x44,0x55};
  3. u_char frame[ETH_LEN_MAX];
  5. eth_pack_hdr(frame, dst, src, ETH_TYPE_ARP);

2.3 MAC地址转换函数

2.3.1 MAC转字符串

  1. // src/addr-util.c:75-92
  2. char*eth_ntop(consteth_addr_t*eth,char*dst,size_t len)
  3. {
  4. constchar*x;
  5. char*p = dst;
  6. int i;
  8. if(len <18)// 需要至少18字节（"xx:xx:xx:xx:xx:xx" + '\0'）
  9. return(NULL);
  11. for(i =0; i < ETH_ADDR_LEN; i++){
  12. for(x = octet2hex[eth->data[i]];(*p =*x)!='\0'; x++, p++)
  13. ;
  14. *p++=':';
  15. }
  16.     p[-1]='\0';// 替换最后的':'为'\0'
  18. return(dst);
  19. }

格式： 00:11:22:33:44:55

2.3.2 字符串转MAC

  1. // src/addr-util.c:104-119
  2. int eth_pton(constchar*p,eth_addr_t*eth)
  3. {
  4. char*ep;
  5. long l;
  6. int i;
  8. for(i =0; i < ETH_ADDR_LEN; i++){
  9.         l = strtol(p,&ep,16);// 十六进制解析
  10. if(ep == p || l <0|| l >0xff||
  11. (i < ETH_ADDR_LEN -1&&*ep !=':'))
  12. break;
  13.         eth->data[i]=(u_char)l;
  14.         p = ep +1;
  15. }
  16. return((i == ETH_ADDR_LEN &&*ep =='\0')?0:-1);
  17. }

支持的格式：

  • 00:11:22:33:44:55（推荐）
  • 00-11-22-33-44-55
  • 0011:2233:4455（部分格式）

2.4 平台适配机制

libdnet通过编译时宏选择不同实现：

实现文件
平台
说明
eth-linux.c
Linux
Packet Socket
eth-bsd.c
macOS/BSD
BPF
eth-dlpi.c
Solaris/HP-UX
DLPI
eth-snoop.c
Solaris
SNOOP
eth-pfilt.c
Tru64
Packet Filter
eth-ndd.c
AIX
NDD
eth-win32.c
Windows
不支持
eth-none.c
无
空实现

3. Linux平台实现

3.1 实现文件

主文件： src/eth-linux.c

3.2 数据结构

  1. // src/eth-linux.c:36-40
  2. struct eth_handle {
  3. int                 fd;// Packet Socket文件描述符
  4. struct ifreq        ifr;// 接口请求结构
  5. struct sockaddr_ll  sll;// 链路层socket地址
  6. };

3.3 打开以太网设备

  1. // src/eth-linux.c:42-67
  2. eth_t*eth_open(constchar*device)
  3. {
  4. eth_t*e;
  5. int n;
  7. if((e = calloc(1,sizeof(*e)))!= NULL){
  8. // 创建Packet Socket
  9. if((e->fd = socket(PF_PACKET, SOCK_RAW,
  10.                  htons(ETH_P_ALL)))<0)
  11. return(eth_close(e));
  13. #ifdef SO_BROADCAST
  14. // 允许广播
  15.         n =1;
  16. if(setsockopt(e->fd, SOL_SOCKET, SO_BROADCAST,&n,
  17. sizeof(n))<0)
  18. return(eth_close(e));
  19. #endif
  20. // 保存接口名称
  21.         strlcpy(e->ifr.ifr_name, device,sizeof(e->ifr.ifr_name));
  23. // 获取接口索引
  24. if(ioctl(e->fd, SIOCGIFINDEX,&e->ifr)<0)
  25. return(eth_close(e));
  27. // 配置链路层socket地址
  28.         e->sll.sll_family = AF_PACKET;
  29.         e->sll.sll_ifindex = e->ifr.ifr_ifindex;
  30. }
  31. return(e);
  32. }

关键技术：

  1. Packet Socket：
  • PF_PACKET：协议族为数据包协议
  • SOCK_RAW：原始套接字
  • ETH_P_ALL：接收所有以太网帧
  1. SIOCGIFINDEX：
  • 获取接口的索引号
  • 用于 sockaddr_ll的 sll_ifindex字段
  1. SO_BROADCAST：
  • 允许发送广播帧

3.4 发送以太网帧

  1. // src/eth-linux.c:69-78
  2. ssize_t eth_send(eth_t*e,constvoid*buf,size_t len)
  3. {
  4. struct eth_hdr *eth =(struct eth_hdr *)buf;
  6. // 设置协议类型
  7.     e->sll.sll_protocol = eth->eth_type;
  9. // 发送数据帧
  10. return(sendto(e->fd, buf, len,0,(struct sockaddr *)&e->sll,
  11. sizeof(e->sll)));
  12. }

说明：

  • eth->eth_type：以太网类型字段
  • sendto：使用链路层地址发送

3.5 获取MAC地址

  1. // src/eth-linux.c:91-104
  2. int eth_get(eth_t*e,eth_addr_t*ea)
  3. {
  4. struct addr ha;
  6. // 使用ioctl获取硬件地址
  7. if(ioctl(e->fd, SIOCGIFHWADDR,&e->ifr)<0)
  8. return(-1);
  10. // 转换为libdnet地址格式
  11. if(addr_ston(&e->ifr.ifr_hwaddr,&ha)<0)
  12. return(-1);
  14. // 提取MAC地址
  15.     memcpy(ea,&ha.addr_eth,sizeof(*ea));
  16. return(0);
  17. }

ioctl命令：

  • SIOCGIFHWADDR：获取接口硬件地址

3.6 设置MAC地址

  1. // src/eth-linux.c:106-118
  2. int eth_set(eth_t*e,consteth_addr_t*ea)
  3. {
  4. struct addr ha;
  6. // 构造地址结构
  7.     ha.addr_type = ADDR_TYPE_ETH;
  8.     ha.addr_bits = ETH_ADDR_BITS;
  9.     memcpy(&ha.addr_eth, ea, ETH_ADDR_LEN);
  11. // 转换为sockaddr格式
  12.     addr_ntos(&ha,&e->ifr.ifr_hwaddr);
  14. // 设置硬件地址
  15. return(ioctl(e->fd, SIOCSIFHWADDR,&e->ifr));
  16. }

ioctl命令：

  • SIOCSIFHWADDR：设置接口硬件地址

注意：需要root权限

3.7 关闭以太网设备

  1. // src/eth-linux.c:80-89
  2. eth_t*eth_close(eth_t*e)
  3. {
  4. if(e != NULL){
  5. if(e->fd >=0)
  6.             close(e->fd);
  7.         free(e);
  8. }
  9. return(NULL);
  10. }

4. macOS/BSD平台实现

4.1 实现文件

主文件： src/eth-bsd.c

4.2 数据结构

  1. // src/eth-bsd.c:34-37
  2. struct eth_handle {
  3. int     fd;// BPF文件描述符
  4. char    device[16];// 接口名称
  5. };

4.3 打开以太网设备

  1. // src/eth-bsd.c:39-74
  2. eth_t*eth_open(constchar*device)
  3. {
  4. struct ifreq ifr;
  5. char file[32];
  6. eth_t*e;
  7. int i;
  9. if((e = calloc(1,sizeof(*e)))!= NULL){
  10. // 尝试打开BPF设备（/dev/bpf0 - /dev/bpf127）
  11. for(i =0; i <128; i++){
  12.             snprintf(file,sizeof(file),"/dev/bpf%d", i);
  13. /* Mac OS X 10.6的bug：O_WRONLY会导致其他进程无法接收流量 */
  14.             e->fd = open(file, O_RDWR);
  15. if(e->fd !=-1|| errno != EBUSY)
  16. break;
  17. }
  18. if(e->fd <0)
  19. return(eth_close(e));
  21. // 绑定到指定接口
  22.         memset(&ifr,0,sizeof(ifr));
  23.         strlcpy(ifr.ifr_name, device,sizeof(ifr.ifr_name));
  25. if(ioctl(e->fd, BIOCSETIF,(char*)&ifr)<0)
  26. return(eth_close(e));
  28. #ifdef BIOCSHDRCMPLT
  29. // 设置标志：驱动不自动填充源MAC地址
  30.         i =1;
  31. if(ioctl(e->fd, BIOCSHDRCMPLT,&i)<0)
  32. return(eth_close(e));
  33. #endif
  34. // 保存设备名称
  35.         strlcpy(e->device, device,sizeof(e->device));
  36. }
  37. return(e);
  38. }

关键技术：

  1. BPF设备：
  • BSD Packet Filter
  • 设备文件： /dev/bpf0到 /dev/bpf127
  • 自动查找可用的BPF设备
  1. BIOCSETIF：
  • 将BPF绑定到指定网络接口
  1. BIOCSHDRCMPLT：
  • 指示驱动程序不自动完成以太网头
  • 允许应用程序发送自定义源MAC地址

4.4 发送以太网帧

  1. // src/eth-bsd.c:76-80
  2. ssize_t eth_send(eth_t*e,constvoid*buf,size_t len)
  3. {
  4. return(write(e->fd, buf, len));
  5. }

说明：

  • 直接向BPF文件描述符写入数据
  • 驱动程序自动处理以太网帧的发送

4.5 获取MAC地址（sysctl方式）

  1. // src/eth-bsd.c:93-138
  2. #if defined(HAVE_SYS_SYSCTL_H) && defined(HAVE_ROUTE_RT_MSGHDR)
  3. int eth_get(eth_t*e,eth_addr_t*ea)
  4. {
  5. struct if_msghdr *ifm;
  6. struct sockaddr_dl *sdl;
  7. struct addr ha;
  8.     u_char *p,*buf;
  9. size_t len;
  10. int mib[]={ CTL_NET, AF_ROUTE,0, AF_LINK, NET_RT_IFLIST,0};
  12. // 获取接口列表所需的缓冲区大小
  13. if(sysctl(mib,6, NULL,&len, NULL,0)<0)
  14. return(-1);
  16. // 分配缓冲区
  17. if((buf = malloc(len))== NULL)
  18. return(-1);
  20. // 获取接口列表
  21. if(sysctl(mib,6, buf,&len, NULL,0)<0){
  22.         free(buf);
  23. return(-1);
  24. }
  26. // 遍历接口列表
  27. for(p = buf; p < buf + len; p += ifm->ifm_msglen){
  28.         ifm =(struct if_msghdr *)p;
  29.         sdl =(struct sockaddr_dl *)(ifm +1);
  31. if(ifm->ifm_type != RTM_IFINFO ||
  32. (ifm->ifm_addrs & RTA_IFP)==0)
  33. continue;
  35. // 检查接口名称匹配
  36. if(sdl->sdl_family != AF_LINK || sdl->sdl_nlen ==0||
  37.             memcmp(sdl->sdl_data, e->device, sdl->sdl_nlen)!=0)
  38. continue;
  40. // 提取MAC地址
  41. if(addr_ston((struct sockaddr *)sdl,&ha)==0)
  42. break;
  43. }
  44.     free(buf);
  46. if(p >= buf + len){
  47.         errno = ESRCH;
  48. return(-1);
  49. }
  50.     memcpy(ea,&ha.addr_eth,sizeof(*ea));
  52. return(0);
  53. }
  54. #endif

关键技术：

  1. sysctl：
  • 系统控制接口
  • 获取内核信息
  1. MIB标识符：
  • CTL_NET：网络相关
  • AF_ROUTE：路由套接字
  • AF_LINK：链路层地址
  • NET_RT_IFLIST：接口列表
  1. sockaddr_dl：
  • 链路层socket地址
  • 包含接口名称和MAC地址

4.6 设置MAC地址

  1. // src/eth-bsd.c:148-164
  2. #if defined(SIOCSIFLLADDR)
  3. int eth_set(eth_t*e,consteth_addr_t*ea)
  4. {
  5. struct ifreq ifr;
  6. struct addr ha;
  8. // 构造地址结构
  9.     ha.addr_type = ADDR_TYPE_ETH;
  10.     ha.addr_bits = ETH_ADDR_BITS;
  11.     memcpy(&ha.addr_eth, ea, ETH_ADDR_LEN);
  13. // 配置ifreq
  14.     memset(&ifr,0,sizeof(ifr));
  15.     strlcpy(ifr.ifr_name, e->device,sizeof(ifr.ifr_name));
  16.     addr_ntos(&ha,&ifr.ifr_addr);
  18. // 设置链路层地址
  19. return(ioctl(e->fd, SIOCSIFLLADDR,&ifr));
  20. }
  21. #endif

ioctl命令：

  • SIOCSIFLLADDR：设置接口链路层地址（BSD特定）

5. Solaris平台实现

5.1 实现文件

主文件： src/eth-dlpi.c、 src/eth-snoop.c

5.2 DLPI实现（Data Link Provider Interface）

5.2.1 数据结构

  1. // src/eth-dlpi.c:42-45
  2. struct eth_handle {
  3. int     fd;// DLPI流文件描述符
  4. int     sap_len;// SAP（服务访问点）长度
  5. };

5.2.2 打开以太网设备

  1. // src/eth-dlpi.c:132-205
  2. eth_t*eth_open(constchar*device)
  3. {
  4. union DL_primitives *dlp;
  5. uint32_t buf[8192];
  6. char*p, dev[16];
  7. eth_t*e;
  8. int ppa;
  10. if((e = calloc(1,sizeof(*e)))== NULL)
  11. return(NULL);
  13. #ifdef HAVE_SYS_DLPIHDR_H
  14. // OSF1/Tru64：使用流设备
  15. if((e->fd = open("/dev/streams/dlb", O_RDWR))<0)
  16. return(eth_close(e));
  18. if((ppa = eth_match_ppa(e, device))<0){
  19.         errno = ESRCH;
  20. return(eth_close(e));
  21. }
  22. #else
  23. // Solaris/HP-UX：使用DLPI设备
  24.     e->fd =-1;
  25.     snprintf(dev,sizeof(dev),"/dev/%s", device);
  27. // 查找PPA（物理点访问点）
  28. if((p = dev_find_ppa(dev))== NULL){
  29.         errno = EINVAL;
  30. return(eth_close(e));
  31. }
  32.     ppa = atoi(p);
  33. *p ='\0';
  35. // 尝试打开设备
  36. if((e->fd = open(dev, O_RDWR))<0){
  37.         snprintf(dev,sizeof(dev),"/dev/%s", device);
  38. if((e->fd = open(dev, O_RDWR))<0){
  39.             snprintf(dev,sizeof(dev),"/dev/net/%s", device);
  40. if((e->fd = open(dev, O_RDWR))<0)
  41. return(eth_close(e));
  42. }
  43. }
  44. #endif
  46. // 获取DLPI提供者信息
  47.     dlp =(union DL_primitives *)buf;
  48.     dlp->info_req.dl_primitive = DL_INFO_REQ;
  50. if(dlpi_msg(e->fd, dlp, DL_INFO_REQ_SIZE, RS_HIPRI,
  51.         DL_INFO_ACK, DL_INFO_ACK_SIZE,sizeof(buf))<0)
  52. return(eth_close(e));
  54.     e->sap_len = dlp->info_ack.dl_sap_length;
  56. // STYLE2：需要附加到PPA
  57. if(dlp->info_ack.dl_provider_style == DL_STYLE2){
  58.         dlp->attach_req.dl_primitive = DL_ATTACH_REQ;
  59.         dlp->attach_req.dl_ppa = ppa;
  61. if(dlpi_msg(e->fd, dlp, DL_ATTACH_REQ_SIZE,0,
  62.             DL_OK_ACK, DL_OK_ACK_SIZE,sizeof(buf))<0)
  63. return(eth_close(e));
  64. }
  66. // 绑定到SAP
  67.     memset(&dlp->bind_req,0, DL_BIND_REQ_SIZE);
  68.     dlp->bind_req.dl_primitive = DL_BIND_REQ;
  69. #ifdef DL_HP_RAWDLS
  70. // HP-UX：原始数据链路服务
  71.     dlp->bind_req.dl_sap =24;
  72.     dlp->bind_req.dl_service_mode = DL_HP_RAWDLS;
  73. #else
  74.     dlp->bind_req.dl_sap = DL_ETHER;
  75.     dlp->bind_req.dl_service_mode = DL_CLDLS;
  76. #endif
  77. if(dlpi_msg(e->fd, dlp, DL_BIND_REQ_SIZE,0,
  78.         DL_BIND_ACK, DL_BIND_ACK_SIZE,sizeof(buf))<0)
  79. return(eth_close(e));
  81. #ifdef DLIOCRAW
  82. // 设置原始模式
  83. if(strioctl(e->fd, DLIOCRAW,0, NULL)<0)
  84. return(eth_close(e));
  85. #endif
  86. return(e);
  87. }

关键技术：

  1. DLPI原语：
  • DL_INFO_REQ：请求提供者信息
  • DL_ATTACH_REQ：附加到PPA（STYLE2）
  • DL_BIND_REQ：绑定到SAP
  • DL_OK_ACK：操作成功确认
  1. DLPI风格：
  • STYLE1：打开时直接附加到PPA
  • STYLE2：需要显式附加到PPA
  1. DLIOCRAW：
  • 设置原始模式
  • 允许发送完整的以太网帧

5.2.3 发送以太网帧

  1. // src/eth-dlpi.c:207-257
  2. ssize_t eth_send(eth_t*e,constvoid*buf,size_t len)
  3. {
  4. #if defined(DLIOCRAW)
  5. // 原始模式：直接写入
  6. return(write(e->fd, buf, len));
  7. #else
  8. union DL_primitives *dlp;
  9. struct strbuf ctl, data;
  10. struct eth_hdr *eth;
  11. uint32_t ctlbuf[8192];
  12.     u_char sap[4]={0,0,0,0};
  13. int dlen;
  15.     dlp =(union DL_primitives *)ctlbuf;
  16. #ifdef DL_HP_RAWDATA_REQ
  17.     dlp->dl_primitive = DL_HP_RAWDATA_REQ;
  18.     dlen = DL_HP_RAWDATA_REQ_SIZE;
  19. #else
  20.     dlp->unitdata_req.dl_primitive = DL_UNITDATA_REQ;
  21.     dlp->unitdata_req.dl_dest_addr_length = ETH_ADDR_LEN;
  22.     dlp->unitdata_req.dl_dest_addr_offset = DL_UNITDATA_REQ_SIZE;
  23.     dlp->unitdata_req.dl_priority.dl_min =
  24.         dlp->unitdata_req.dl_priority.dl_max =0;
  25.     dlen = DL_UNITDATA_REQ_SIZE;
  26. #endif
  28. // 提取以太网类型
  29.     eth =(struct eth_hdr *)buf;
  30. *(uint16_t*)sap = ntohs(eth->eth_type);
  32. // 构造控制消息
  33.     ctl.maxlen =0;
  34.     ctl.len = dlen + ETH_ADDR_LEN + abs(e->sap_len);
  35.     ctl.buf =(char*)ctlbuf;
  37. // 设置SAP和目标地址
  38. if(e->sap_len >=0){
  39.         memcpy(ctlbuf + dlen, sap, e->sap_len);
  40.         memcpy(ctlbuf + dlen + e->sap_len,
  41.             eth->eth_dst.data, ETH_ADDR_LEN);
  42. }else{
  43.         memcpy(ctlbuf + dlen, eth->eth_dst.data, ETH_ADDR_LEN);
  44.         memcpy(ctlbuf + dlen + ETH_ADDR_LEN, sap, abs(e->sap_len));
  45. }
  47. // 设置数据消息
  48.     data.maxlen =0;
  49.     data.len = len;
  50.     data.buf =(char*)buf;
  52. // 发送消息
  53. if(putmsg(e->fd,&ctl,&data,0)<0)
  54. return(-1);
  56. return(len);
  57. #endif
  58. }

STREAMS消息：

  • putmsg：发送消息
  • strbuf：控制消息和数据消息

5.2.4 获取MAC地址

  1. // src/eth-dlpi.c:270-287
  2. int eth_get(eth_t*e,eth_addr_t*ea)
  3. {
  4. union DL_primitives *dlp;
  5.     u_char buf[2048];
  7.     dlp =(union DL_primitives *)buf;
  8.     dlp->physaddr_req.dl_primitive = DL_PHYS_ADDR_REQ;
  9.     dlp->physaddr_req.dl_addr_type = DL_CURR_PHYS_ADDR;
  11. if(dlpi_msg(e->fd, dlp, DL_PHYS_ADDR_REQ_SIZE,0,
  12.         DL_PHYS_ADDR_ACK, DL_PHYS_ADDR_ACK_SIZE,sizeof(buf))<0)
  13. return(-1);
  15.     memcpy(ea, buf + dlp->physaddr_ack.dl_addr_offset,sizeof(*ea));
  17. return(0);
  18. }

5.2.5 设置MAC地址

  1. // src/eth-dlpi.c:289-304
  2. int eth_set(eth_t*e,consteth_addr_t*ea)
  3. {
  4. union DL_primitives *dlp;
  5.     u_char buf[2048];
  7.     dlp =(union DL_primitives *)buf;
  8.     dlp->set_physaddr_req.dl_primitive = DL_SET_PHYS_ADDR_REQ;
  9.     dlp->set_physaddr_req.dl_addr_length = ETH_ADDR_LEN;
  10.     dlp->set_physaddr_req.dl_addr_offset = DL_SET_PHYS_ADDR_REQ_SIZE;
  12.     memcpy(buf + DL_SET_PHYS_ADDR_REQ_SIZE, ea,sizeof(*ea));
  14. return(dlpi_msg(e->fd, dlp, DL_SET_PHYS_ADDR_REQ_SIZE + ETH_ADDR_LEN,
  15. 0, DL_OK_ACK, DL_OK_ACK_SIZE,sizeof(buf)));
  16. }

5.3 SNOOP实现（Solaris）

5.3.1 数据结构

  1. // src/eth-snoop.c:25-28
  2. struct eth_handle {
  3. int     fd;// SNOOP socket
  4. struct ifreq ifr;// 接口请求结构
  5. };

5.3.2 打开以太网设备

  1. // src/eth-snoop.c:30-57
  2. eth_t*eth_open(constchar*device)
  3. {
  4. struct sockaddr_raw sr;
  5. eth_t*e;
  6. int n;
  8. if((e = calloc(1,sizeof(*e)))== NULL)
  9. return(NULL);
  11. // 创建SNOOP原始socket
  12. if((e->fd = socket(PF_RAW, SOCK_RAW, RAWPROTO_SNOOP))<0)
  13. return(eth_close(e));
  15. // 配置socket地址
  16.     memset(&sr,0,sizeof(sr));
  17.     sr.sr_family = AF_RAW;
  18.     strlcpy(sr.sr_ifname, device,sizeof(sr.sr_ifname));
  20. // 绑定到接口
  21. if(bind(e->fd,(struct sockaddr *)&sr,sizeof(sr))<0)
  22. return(eth_close(e));
  24. // 设置发送缓冲区
  25.     n =60000;
  26. if(setsockopt(e->fd, SOL_SOCKET, SO_SNDBUF,&n,sizeof(n))<0)
  27. return(eth_close(e));
  29.     strlcpy(e->ifr.ifr_name, device,sizeof(e->ifr.ifr_name));
  31. return(e);
  32. }

5.3.3 获取/设置MAC地址

  1. // src/eth-snoop.c:59-92
  2. int eth_get(eth_t*e,eth_addr_t*ea)
  3. {
  4. struct addr ha;
  6. if(ioctl(e->fd, SIOCGIFADDR,&e->ifr)<0)
  7. return(-1);
  9. if(addr_ston(&e->ifr.ifr_addr,&ha)<0)
  10. return(-1);
  12. if(ha.addr_type != ADDR_TYPE_ETH){
  13.         errno = EINVAL;
  14. return(-1);
  15. }
  16.     memcpy(ea,&ha.addr_eth,sizeof(*ea));
  18. return(0);
  19. }
  21. int eth_set(eth_t*e,consteth_addr_t*ea)
  22. {
  23. struct addr ha;
  25.     ha.addr_type = ADDR_TYPE_ETH;
  26.     ha.addr_bits = ETH_ADDR_BITS;
  27.     memcpy(&ha.addr_eth, ea, ETH_ADDR_LEN);
  29. if(addr_ntos(&ha,&e->ifr.ifr_addr)<0)
  30. return(-1);
  32. return(ioctl(e->fd, SIOCSIFADDR,&e->ifr));
  33. }

6. HP-UX平台实现

HP-UX使用DLPI实现，已在5.2节详细说明。

特殊之处：

  1. // src/eth-dlpi.c:190-192
  2. #ifdef DL_HP_RAWDLS
  3.     dlp->bind_req.dl_sap =24;// HP-UX专用值
  4.     dlp->bind_req.dl_service_mode = DL_HP_RAWDLS;
  5. #endif

7. AIX平台实现

7.1 实现文件

主文件： src/eth-ndd.c

7.2 数据结构

  1. // src/eth-ndd.c:25-28
  2. struct eth_handle {
  3. char    device[16];// 接口名称
  4. int     fd;// NDD socket
  5. };

7.3 打开以太网设备

  1. // src/eth-ndd.c:30-58
  2. eth_t*eth_open(constchar*device)
  3. {
  4. struct sockaddr_ndd_8022 sa;
  5. eth_t*e;
  7. if((e = calloc(1,sizeof(*e)))== NULL)
  8. return(NULL);
  10. // 创建NDD socket
  11. if((e->fd = socket(AF_NDD, SOCK_DGRAM, NDD_PROT_ETHER))<0)
  12. return(eth_close(e));
  14. // 配置socket地址
  15.     sa.sndd_8022_family = AF_NDD;
  16.     sa.sndd_8022_len =sizeof(sa);
  17.     sa.sndd_8022_filtertype = NS_ETHERTYPE;
  18.     sa.sndd_8022_ethertype =0;
  19.     sa.sndd_8022_filterlen =sizeof(struct ns_8022);
  20.     strlcpy(sa.sndd_8022_nddname, device,sizeof(sa.sndd_8022_nddname));
  22. // 绑定socket
  23. if(bind(e->fd,(struct sockaddr *)&sa,sizeof(sa))<0)
  24. return(eth_close(e));
  26. // 连接socket
  27. if(connect(e->fd,(struct sockaddr *)&sa,sizeof(sa))<0)
  28. return(eth_close(e));
  30. return(e);
  31. }

NDD（Network Device Driver）：

  • AIX专用的网络设备驱动接口
  • 用于直接访问底层网络设备

7.4 获取MAC地址

  1. // src/eth-ndd.c:77-110
  2. int eth_get(eth_t*e,eth_addr_t*ea)
  3. {
  4. struct kinfo_ndd *nddp;
  5. int size;
  6. void*end;
  8. // 获取NDD信息所需的缓冲区大小
  9. if((size = getkerninfo(KINFO_NDD,0,0,0))==0){
  10.         errno = ENOENT;
  11. return(-1);
  12. }elseif(size <0)
  13. return(-1);
  15. // 分配缓冲区
  16. if((nddp = malloc(size))== NULL)
  17. return(-1);
  19. // 获取NDD信息
  20. if(getkerninfo(KINFO_NDD, nddp,&size,0)<0){
  21.         free(nddp);
  22. return(-1);
  23. }
  25. // 遍历NDD列表
  26. for(end =(void*)nddp + size;(void*)nddp < end; nddp++){
  27. if(strcmp(nddp->ndd_alias, e->device)==0||
  28.             strcmp(nddp->ndd_name, e->device)==0){
  29.             memcpy(ea, nddp->ndd_addr,sizeof(*ea));
  30. }
  31. }
  32.     free(nddp);
  34. if((void*)nddp >= end){
  35.         errno = ESRCH;
  36. return(-1);
  37. }
  38. return(0);
  39. }

getkerninfo：

  • AIX的内核信息接口
  • KINFO_NDD：网络设备驱动信息

8. Windows平台实现

8.1 实现文件

主文件： src/eth-win32.c

8.2 当前状态

  1. // src/eth-win32.c:23-50
  2. eth_t*eth_open(constchar*device)
  3. {
  4. return(NULL);// 不支持
  5. }
  7. ssize_t eth_send(eth_t*eth,constvoid*buf,size_t len)
  8. {
  9. return(-1);// 不支持
  10. }
  12. eth_t*eth_close(eth_t*eth)
  13. {
  14. return(NULL);
  15. }
  17. int eth_get(eth_t*eth,eth_addr_t*ea)
  18. {
  19. return(-1);// 不支持
  20. }
  22. int eth_set(eth_t*eth,consteth_addr_t*ea)
  23. {
  24. return(-1);// 不支持
  25. }

说明：

  • Windows平台不直接支持原始以太网帧发送
  • 需要使用第三方库（如WinPcap/Npcap）
  • libdnet的Windows实现仅提供框架

8.3 替代方案

在Windows上，可以使用以下库：

  1. WinPcap/Npcap：提供类似BPF的功能
  2. Raw Sockets：功能有限，仅支持部分协议
  3. Packet.dll：底层数据包捕获和发送

9. 跨平台对比分析

9.1 API设计对比

功能
Linux
macOS/BSD
Solaris
HP-UX
AIX
Windows
打开设备
Packet Socket
BPF
DLPI/SNOOP
DLPI
NDD
不支持
获取MAC
SIOCGIFHWADDR
sysctl
DLPHYSADDR_REQ
DLPHYSADDR_REQ
getkerninfo
不支持
设置MAC
SIOCSIFHWADDR
SIOCSIFLLADDR
DLSETPHYSADDRREQ
DLSETPHYSADDRREQ
不支持
不支持
发送帧
sendto
write
putmsg/write
putmsg/write
write
不支持
接收帧
recvfrom
read
getmsg
getmsg
read
不支持

9.2 数据结构对比

平台
主要结构
说明
Linux sockaddr_ll
链路层socket地址
macOS/BSD sockaddr_dl
链路层socket地址
Solaris DL_primitives
DLPI原语联合体
AIX sockaddr_ndd_8022
NDD socket地址

9.3 操作方式对比

Linux

  1. // Packet Socket方式
  2. int fd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
  3. struct sockaddr_ll sll;
  4. sendto(fd, buf, len,0,(struct sockaddr *)&sll,sizeof(sll));

macOS/BSD

  1. // BPF方式
  2. int fd = open("/dev/bpf0", O_RDWR);
  3. ioctl(fd, BIOCSETIF,&ifr);
  4. write(fd, buf, len);

Solaris (DLPI)

  1. // DLPI方式
  2. int fd = open("/dev/hme", O_RDWR);
  3. putmsg(fd,&ctl,&data,0);

9.4 性能对比

操作
Linux
macOS/BSD
Solaris
AIX
打开设备
快
中
慢（STREAMS）
慢
发送帧
快
快
中（putmsg）
中
获取MAC
快（ioctl）
中（sysctl）
慢（DLPI）
慢（getkerninfo）
设置MAC
快（ioctl）
快（ioctl）
慢（DLPI）
不支持

9.5 权限要求对比

操作
Linux
macOS/BSD
Solaris
HP-UX
AIX
打开设备
root/CAPNETRAW
root
root
root
root
获取MAC
普通用户
普通用户
普通用户
普通用户
普通用户
设置MAC
root
root
root
root
不支持
发送帧
root
root
root
root
root

9.6 代码复杂度对比

文件
行数
平台
复杂度
eth-linux.c
119
Linux
低
eth-bsd.c
173
macOS/BSD
中
eth-dlpi.c
305
Solaris/HP-UX
高
eth-snoop.c
110
Solaris
中
eth-pfilt.c
88
Tru64
低
eth-ndd.c
118
AIX
中
eth-win32.c
51
Windows
低（不支持）

9.7 维护性分析

方面
Linux
macOS/BSD
Solaris
AIX
API稳定性
高
高
中
低
平台差异
低
低
高（DLPI风格）
高
代码复用
高
高
中
低
测试难度
低
中
高
高

9.8 特殊功能对比

功能
Linux
macOS/BSD
Solaris
AIX
VLAN支持
原生
原生
原生
有限
混杂模式
支持
支持
支持
支持
自定义源MAC
支持
支持（BIOCSHDRCMPLT）
支持
有限
驱动信息
支持（ethtool）
不支持
不支持
不支持

10. 实际应用示例

10.1 基本用法：获取MAC地址

  1. #include<stdio.h>
  2. #include<dnet.h>
  4. int main(void)
  5. {
  6. eth_t*eth;
  7. eth_addr_t ea;
  8. char buf[18];
  10. if((eth = eth_open("eth0"))== NULL){
  11.         perror("eth_open");
  12. return(1);
  13. }
  15. if(eth_get(eth,&ea)<0){
  16.         perror("eth_get");
  17. return(1);
  18. }
  20.     printf("MAC地址: %s\n", eth_ntop(&ea, buf,sizeof(buf)));
  22.     eth_close(eth);
  23. return(0);
  24. }

10.2 设置MAC地址（需要root权限）

  1. #include<stdio.h>
  2. #include<dnet.h>
  4. int main(void)
  5. {
  6. eth_t*eth;
  7. eth_addr_t new_ea ={0x00,0x11,0x22,0x33,0x44,0x55};
  9. if((eth = eth_open("eth0"))== NULL){
  10.         perror("eth_open");
  11. return(1);
  12. }
  14. if(eth_set(eth,&new_ea)<0){
  15.         perror("eth_set");
  16. return(1);
  17. }
  19.     printf("MAC地址设置成功\n");
  21.     eth_close(eth);
  22. return(0);
  23. }

10.3 发送ARP请求

  1. #include<stdio.h>
  2. #include<dnet.h>
  3. #include<stdint.h>
  5. struct arp_hdr {
  6. uint16_t arp_hrd;// 硬件类型
  7. uint16_t arp_pro;// 协议类型
  8. uint8_t  arp_hln;// 硬件地址长度
  9. uint8_t  arp_pln;// 协议地址长度
  10. uint16_t arp_op;// 操作码
  11. eth_addr_t arp_sha;// 发送方硬件地址
  12. uint32_t  arp_spa;// 发送方协议地址
  13. eth_addr_t arp_tha;// 目标硬件地址
  14. uint32_t  arp_tpa;// 目标协议地址
  15. };
  17. int main(void)
  18. {
  19. eth_t*eth;
  20. eth_addr_t dst_mac ={0xff,0xff,0xff,0xff,0xff,0xff};
  21. eth_addr_t src_mac;
  22.     u_char frame[512];
  23. struct eth_hdr *eth_hdr;
  24. struct arp_hdr *arp_hdr;
  26. if((eth = eth_open("eth0"))== NULL){
  27.         perror("eth_open");
  28. return(1);
  29. }
  31. // 获取本地MAC地址
  32. if(eth_get(eth,&src_mac)<0){
  33.         perror("eth_get");
  34. return(1);
  35. }
  37. // 构造以太网头
  38.     eth_hdr =(struct eth_hdr *)frame;
  39.     eth_pack_hdr(eth_hdr, dst_mac, src_mac, ETH_TYPE_ARP);
  41. // 构造ARP头
  42.     arp_hdr =(struct arp_hdr *)(frame + ETH_HDR_LEN);
  43.     arp_hdr->arp_hrd = htons(1);// 以太网
  44.     arp_hdr->arp_pro = htons(0x0800);// IPv4
  45.     arp_hdr->arp_hln =6;
  46.     arp_hdr->arp_pln =4;
  47.     arp_hdr->arp_op = htons(1);// ARP请求
  48.     memcpy(&arp_hdr->arp_sha,&src_mac, ETH_ADDR_LEN);
  49.     arp_hdr->arp_spa = inet_addr("192.168.1.100");
  50.     memset(&arp_hdr->arp_tha,0, ETH_ADDR_LEN);
  51.     arp_hdr->arp_tpa = inet_addr("192.168.1.1");
  53. // 发送ARP请求
  54. if(eth_send(eth, frame, ETH_HDR_LEN +sizeof(struct arp_hdr))<0){
  55.         perror("eth_send");
  56. return(1);
  57. }
  59.     printf("ARP请求已发送\n");
  61.     eth_close(eth);
  62. return(0);
  63. }

10.4 MAC地址转换

  1. #include<stdio.h>
  2. #include<dnet.h>
  4. int main(void)
  5. {
  6. eth_addr_t ea;
  7. char buf[18];
  9. // 字符串转MAC
  10. if(eth_pton("00:11:22:33:44:55",&ea)<0){
  11.         perror("eth_pton");
  12. return(1);
  13. }
  15. // MAC转字符串
  16.     printf("MAC地址: %s\n", eth_ntop(&ea, buf,sizeof(buf)));
  18. // MAC转字符串（简写）
  19.     printf("MAC地址: %s\n", eth_ntoa(&ea));
  21. return(0);
  22. }

10.5 扫描本地网络MAC地址

  1. #include<stdio.h>
  2. #include<dnet.h>
  4. int scan_intf(conststruct intf_entry *entry,void*arg)
  5. {
  6. eth_t*eth;
  7. eth_addr_t ea;
  8. char buf[18];
  10. // 只处理以太网接口
  11. if(entry->intf_type != INTF_TYPE_ETH)
  12. return(0);
  14. // 只处理up状态的接口
  15. if(!(entry->intf_flags & INTF_FLAG_UP))
  16. return(0);
  18.     printf("接口: %s\n", entry->intf_name);
  20. if((eth = eth_open(entry->intf_name))== NULL){
  21.         printf("  无法打开: %s\n", strerror(errno));
  22. return(0);
  23. }
  25. if(eth_get(eth,&ea)<0){
  26.         printf("  无法获取MAC: %s\n", strerror(errno));
  27. }else{
  28.         printf("  MAC: %s\n", eth_ntop(&ea, buf,sizeof(buf)));
  29. }
  31.     eth_close(eth);
  32. return(0);
  33. }
  35. int main(void)
  36. {
  37. intf_t*intf;
  39. if((intf = intf_open())== NULL){
  40.         perror("intf_open");
  41. return(1);
  42. }
  44.     intf_loop(intf, scan_intf, NULL);
  46.     intf_close(intf);
  47. return(0);
  48. }

10.6 检测MAC地址重复

  1. #include<stdio.h>
  2. #include<dnet.h>
  3. #include<string.h>
  5. #define MAX_INTERFACES 32
  7. struct mac_entry {
  8. char name[16];
  9. eth_addr_t mac;
  10. };
  12. int main(void)
  13. {
  14. intf_t*intf;
  15. eth_t*eth;
  16. struct intf_entry entry;
  17. struct mac_entry macs[MAX_INTERFACES];
  18. int count =0, i, j;
  19. char buf[18], ebuf[1024];
  21. if((intf = intf_open())== NULL){
  22.         perror("intf_open");
  23. return(1);
  24. }
  26.     memset(&entry,0,sizeof(entry));
  27.     entry.intf_len =sizeof(ebuf);
  29. // 遍历所有接口
  30. while(count < MAX_INTERFACES){
  31. if(intf_loop(intf, NULL, NULL)<0)
  32. break;
  34. // 简化示例：实际需要完整遍历
  35. break;
  36. }
  38. // 检查重复MAC
  39. for(i =0; i < count; i++){
  40. for(j = i +1; j < count; j++){
  41. if(memcmp(&macs[i].mac,&macs[j].mac, ETH_ADDR_LEN)==0){
  42.                 printf("警告: MAC地址重复！\n");
  43.                 printf("  %s: %s\n", macs[i].name,
  44.                        eth_ntop(&macs[i].mac, buf,sizeof(buf)));
  45.                 printf("  %s: %s\n", macs[j].name,
  46.                        eth_ntop(&macs[j].mac, buf,sizeof(buf)));
  47. }
  48. }
  49. }
  51.     intf_close(intf);
  52. return(0);
  53. }

10.7 使用dnet命令行工具

  1. # 构造以太网帧
  2. $ echo "hello"| dnet eth type 0x0800 src 00:11:22:33:44:55 dst ff:ff:ff:ff:ff:ff > frame.bin
  4. # 发送以太网帧（需要root）
  5. $ sudo dnet send eth0 < frame.bin
  7. # 显示ARP缓存
  8. $ dnet arp show
  10. # 添加ARP条目
  11. $ sudo dnet arp add 192.168.1.100:11:22:33:44:55

11. 常见问题与解决方案

11.1 权限问题

问题：

  1. eth_open:Permission denied

原因：打开原始socket需要root权限

解决方案：

  1. # Linux/macOS/BSD
  2. sudo ./your_program
  4. # 添加CAP_NET_RAW能力（仅Linux）
  5. sudo setcap cap_net_raw+ep ./your_program

11.2 设备不存在

问题：

  1. eth_open:No such device

原因：接口名称错误

解决方案：

  1. // 首先列出所有接口
  2. intf_loop(intf, print_intf, NULL);
  4. // 确认接口名称后再使用
  5. strlcpy(device,"eth0",sizeof(device));

11.3 BPF设备全部忙碌

问题：

  1. eth_open:Device busy

原因：所有BPF设备都被占用

解决方案：

  1. // 检查BPF设备占用
  2. $ ls -l /dev/bpf*
  3. $ lsof /dev/bpf*
  5. // 释放未使用的BPF设备
  6. // 或增加BPF设备数量（需要配置内核）

11.4 macOS/BSD无法发送自定义源MAC

问题：发送的帧源MAC总是被覆盖

原因：驱动程序自动完成以太网头

解决方案：

  1. // 设置BIOCSHDRCMPLT标志
  2. int i =1;
  3. ioctl(fd, BIOCSHDRCMPLT,&i);

11.5 DLPI附加失败

问题：

  1. eth_open: DLPI attach failed

原因：PPA值错误或设备不支持

解决方案：

  1. // 检查PPA值
  2. $ ls -l /dev/net/
  3. $ netstat -in
  5. // 尝试不同的DLPI风格

11.6 AIX getkerninfo失败

问题：

  1. eth_get:No such file or directory

原因：NDD信息不可用

解决方案：

  1. # 检查NDD配置
  2. $ lsdev -C | grep -i ether
  3. $ netstat -ia
  5. # 可能需要加载NDD驱动

11.7 MAC地址格式错误

问题：

  1. eth_pton:Invalid argument

原因：MAC地址格式不正确

解决方案：

  1. // 支持的格式
  2. "00:11:22:33:44:55"// 推荐
  3. "00-11-22-33-44-55"
  4. "0011:2233:4455"
  6. // 不支持的格式
  7. "001122334455"
  8. "00:11:22:33:44:55:66"// 长度错误

11.8 发送帧长度错误

问题：

  1. eth_send:Message too long

原因：帧长度超过MTU

解决方案：

  1. // 检查帧长度
  2. if(len > ETH_MTU){
  3.     fprintf(stderr,"帧长度超过MTU: %zu > %d\n", len, ETH_MTU);
  4. return(-1);
  5. }
  7. // 或分片发送

11.9 性能优化：缓冲区管理

问题：频繁打开/关闭设备导致性能下降

解决方案：

  1. // 缓存设备句柄
  2. staticeth_t*eth_cache[MAX_INTERFACES];
  3. staticchar dev_cache[MAX_INTERFACES][16];
  5. eth_t*eth_get_cached(constchar*device)
  6. {
  7. int i;
  9. // 查找缓存
  10. for(i =0; i < MAX_INTERFACES; i++){
  11. if(dev_cache[i][0]!='\0'&&
  12.             strcmp(dev_cache[i], device)==0){
  13. return(eth_cache[i]);
  14. }
  15. }
  17. // 未找到，打开新设备
  18. for(i =0; i < MAX_INTERFACES; i++){
  19. if(dev_cache[i][0]=='\0'){
  20.             eth_cache[i]= eth_open(device);
  21. if(eth_cache[i]!= NULL){
  22.                 strlcpy(dev_cache[i], device,sizeof(dev_cache[i]));
  23. }
  24. return(eth_cache[i]);
  25. }
  26. }
  28. return(NULL);
  29. }

11.10 调试技巧

启用详细日志

  1. #define DEBUG_ETH 1
  3. #ifdef DEBUG_ETH
  4. #define DEBUG(fmt,...) fprintf(stderr,"[DEBUG] " fmt "\n",##__VA_ARGS__)
  5. #else
  6. #define DEBUG(fmt,...)
  7. #endif
  9. // 在关键位置添加日志
  10. DEBUG("打开设备: %s", device);
  11. DEBUG("获取MAC: %s", eth_ntop(&ea, buf,sizeof(buf)));
  12. DEBUG("发送帧: %zu 字节", len);

使用系统工具验证

  1. # Linux
  2. $ ip link show
  3. $ ip link set eth0 address 00:11:22:33:44:55
  5. # macOS/BSD
  6. $ ifconfig en0
  7. $ ifconfig en0 ether 00:11:22:33:44:55
  9. # Solaris
  10. $ ifconfig -a
  11. $ ifconfig hme0 ether 00:11:22:33:44:55
  13. # AIX
  14. $ netstat -ia
  15. $ chdev -l en0 -a netaddr=0x001122334455

抓包验证

  1. # 使用tcpdump抓包
  2. $ sudo tcpdump -i eth0 -XX
  4. # 使用Wireshark分析
  5. $ sudo tshark -i eth0

总结

本文档深入分析了libdnet MAC地址处理模块的跨平台实现，涵盖了以下核心内容：

主要特点

  1. 七大平台支持：
  • Linux：Packet Socket
  • macOS/BSD：BPF
  • Solaris：DLPI/SNOOP
  • HP-UX：DLPI
  • AIX：NDD
  • Tru64：Packet Filter
  • Windows：不支持（需要第三方库）
  1. 核心功能：
  • MAC地址获取/设置
  • 以太网帧发送
  • MAC地址格式转换
  • 支持VLAN标签
  1. 跨平台适配：
  • 条件编译处理平台差异
  • 统一的API接口
  • 灵活的数据结构设计

实现亮点

  • Linux：简单高效的Packet Socket
  • macOS/BSD：成熟的BPF机制，sysctl获取MAC
  • Solaris：复杂的DLPI STREAMS接口
  • AIX：独特的getkerninfo接口

使用建议

  1. 优先使用读取操作：避免频繁修改MAC地址
  2. 注意权限要求：大多数操作需要root权限
  3. 处理平台差异：不同平台支持的功能不同
  4. 错误处理：正确处理平台特定的错误码

通过本文档，开发者可以全面理解libdnet MAC地址处理模块的设计思想和实现细节，并在不同平台上正确使用该库。

  • 公众号:安全狗的自我修养

  • vx:2207344074

  • http://gitee.com/haidragon

  • http://github.com/haidragon

  • bilibili:haidragonx

AD：【资源若失效或者不可用，请留言评论或加老夜微信 al_tmen】>>点此前往<<
本站文章均为手工撰写未经允许谢绝转载：夜雨聆风 » 跨平台底层网络库libdnet源码分析系列(七)

wang

猜你喜欢

  • 暂无文章