struct can_frame {
 canid_t can_id; /* CAN 标识符 */
 __u8 can_dlc; /* 数据长度（最长为 8 个字节） */
 __u8 __pad; /* padding */
 __u8 __res0; /* reserved / padding */
 __u8 __res1; /* reserved / padding */
 __u8 data[8]; /* 数据 */
};

/* special address description flags for the CAN_ID */
#define CAN_EFF_FLAG 0x80000000U /* 扩展帧的标识 */
#define CAN_RTR_FLAG 0x40000000U /* 远程帧的标识 */
#define CAN_ERR_FLAG 0x20000000U /* 错误帧的标识，用于错误检查 */
/* mask */
#define CAN_SFF_MASK 0x000007FFU /* <can_id & CAN_SFF_MASK>获取标准帧 ID */
#define CAN_EFF_MASK 0x1FFFFFFFU /* <can_id & CAN_EFF_MASK>获取标准帧 ID */
#define CAN_ERR_MASK 0x1FFFFFFFU /* omit EFF, RTR, ERR flags */

struct can_frame frame; //定义一个 can_frame 变量
int ret;
frame.can_id = 123;//如果为扩展帧，那么 frame.can_id = CAN_EFF_FLAG | 123;
frame.can_dlc = 3; //数据长度为 3
frame.data[0] = 0xA0; //数据内容为 0xA0
frame.data[1] = 0xB0; //数据内容为 0xB0
frame.data[2] = 0xC0; //数据内容为 0xC0
ret = write(sockfd, &frame, sizeof(frame)); //发送数据
if(sizeof(frame) != ret) //如果 ret 不等于帧长度，就说明发送失败
 perror("write error");

struct can_frame frame;
frame.can_id = CAN_RTR_FLAG | 123;
write(sockfd, &frame, sizeof(frame));

struct can_frame frame;
int ret = read(sockfd, &frame, sizeof(frame));

/* error class (mask) in can_id */
#define CAN_ERR_TX_TIMEOUT 0x00000001U /* TX timeout (by netdevice driver) */
#define CAN_ERR_LOSTARB 0x00000002U /* lost arbitration / data[0] */
#define CAN_ERR_CRTL 0x00000004U /* controller problems / data[1] */
#define CAN_ERR_PROT 0x00000008U /* protocol violations / data[2..3] */
#define CAN_ERR_TRX 0x00000010U /* transceiver status / data[4] */
#define CAN_ERR_ACK 0x00000020U /* received no ACK on transmission */
#define CAN_ERR_BUSOFF 0x00000040U /* bus off */
#define CAN_ERR_BUSERROR 0x00000080U /* bus error (may flood!) */
#define CAN_ERR_RESTARTED 0x00000100U /* controller restarted */
......
......

int loopback = 0; //0 表示关闭，1 表示开启(默认)
setsockopt(sockfd, SOL_CAN_RAW, CAN_RAW_LOOPBACK, &loopback, sizeof(loopback));

 CAN 数据发送实例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <linux/can.h>
#include <linux/can/raw.h>
#include <net/if.h>
int main(void)
{
 struct ifreq ifr = {0};
 struct sockaddr_can can_addr = {0};
 struct can_frame frame = {0};
 int sockfd = -1;
 int ret;

 /* 打开套接字 */
 sockfd = socket(PF_CAN, SOCK_RAW, CAN_RAW);
     if(0 > sockfd) {
     perror("socket error");
     exit(EXIT_FAILURE);
 }

 /* 指定 can0 设备 */
 strcpy(ifr.ifr_name, "can0");
 ioctl(sockfd, SIOCGIFINDEX, &ifr);
 can_addr.can_family = AF_CAN;
 can_addr.can_ifindex = ifr.ifr_ifindex;

 /* 将 can0 与套接字进行绑定 */
 ret = bind(sockfd, (struct sockaddr *)&can_addr, sizeof(can_addr));
 if (0 > ret) {
 perror("bind error");
 close(sockfd);
 exit(EXIT_FAILURE);
}

 /* 设置过滤规则：不接受任何报文、仅发送数据 */
 setsockopt(sockfd, SOL_CAN_RAW, CAN_RAW_FILTER, NULL, 0);

 /* 发送数据 */
 frame.data[0] = 0xA0;
 frame.data[1] = 0xB0;
 frame.data[2] = 0xC0;
 frame.data[3] = 0xD0;
 frame.data[4] = 0xE0;
 frame.data[5] = 0xF0;
 frame.can_dlc = 6; //一次发送 6 个字节数据
 frame.can_id = 0x123;//帧 ID 为 0x123,标准帧
 for ( ; ; ) {
 ret = write(sockfd, &frame, sizeof(frame)); //发送数据
 if(sizeof(frame) != ret) { //如果 ret 不等于帧长度，就说明发送失败
 perror("write error");
 goto out;
 }
 sleep(1); //一秒钟发送一次
 }
out:

 /* 关闭套接字 */
 close(sockfd);
 exit(EXIT_SUCCESS);
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <linux/can.h>
#include <linux/can/raw.h>
#include <net/if.h>
int main(void)
{
 struct ifreq ifr = {0};
 struct sockaddr_can can_addr = {0};
 struct can_frame frame = {0};
 int sockfd = -1;
 int i;
 int ret;

 /* 打开套接字 */
 sockfd = socket(PF_CAN, SOCK_RAW, CAN_RAW);
 if(0 > sockfd) {
 perror("socket error");
 exit(EXIT_FAILURE);
 }

 /* 指定 can0 设备 */
 strcpy(ifr.ifr_name, "can0");
 ioctl(sockfd, SIOCGIFINDEX, &ifr);
 can_addr.can_family = AF_CAN;
 can_addr.can_ifindex = ifr.ifr_ifindex;

 /* 将 can0 与套接字进行绑定 */
 ret = bind(sockfd, (struct sockaddr *)&can_addr, sizeof(can_addr));
 if (0 > ret) {
 perror("bind error");
 close(sockfd);
 exit(EXIT_FAILURE);
 }

 /* 设置过滤规则 */
 //setsockopt(sockfd, SOL_CAN_RAW, CAN_RAW_FILTER, NULL, 0);

 /* 接收数据 */
 for ( ; ; ) {
 if (0 > read(sockfd, &frame, sizeof(struct can_frame))) {
 perror("read error");
break;
 }

 /* 校验是否接收到错误帧 */
 if (frame.can_id & CAN_ERR_FLAG) {
 printf("Error frame!\n");
 break;
 }

 /* 校验帧格式 */
 if (frame.can_id & CAN_EFF_FLAG) //扩展帧
 printf("扩展帧 <0x%08x> ", frame.can_id & CAN_EFF_MASK);
 else //标准帧
 printf("标准帧 <0x%03x> ", frame.can_id & CAN_SFF_MASK);

 /* 校验帧类型：数据帧还是远程帧 */
 if (frame.can_id & CAN_RTR_FLAG) {
 printf("remote request\n");
 continue;
 }

 /* 打印数据长度 */
 printf("[%d] ", frame.can_dlc);

 /* 打印数据 */
 for (i = 0; i < frame.can_dlc; i++)
 printf("%02x ", frame.data[i]);
 printf("\n");
 }

 /* 关闭套接字 */
 close(sockfd);
 exit(EXIT_SUCCESS);
}