CAN XL
ISO 11898-1:2024 — Extra Large

/* CAN XL frame — Linux 6.2+ */
struct canxl_frame {
    canid_t  prio;        /* 11-bit öncelik (CAN_XL_PRIO_MASK = 0x7FF) */
    __u8     flags;       /* CANXL_SEC ve diğer flag'lar */
    __u8     sdt;         /* SDU Type (servis veri birimi türü) */
    __u16    len;         /* payload uzunluğu: 1-2048 */
    __u32    af;          /* Acceptance Field (VCID + ek bilgi) */
    __u8     data[CANXL_MAX_DLEN];  /* CANXL_MAX_DLEN = 2048 */
};

/* Sabitleri */
#define CANXL_MAX_DLEN   2048
#define CANXL_MTU        (sizeof(struct canxl_frame))
/* CANXL_MTU = sizeof(canxl_frame) = 4+1+1+2+4+2048 = 2060 byte */

/* prio alanındaki XL tanımlama flag'ı */
#define CAN_XL_PRIO_MASK  0x000007FFU
#define CANXL_XLF         0x80000000U  /* XL Frame flag — prio içinde */

/* flags bitleri */
#define CANXL_SEC  0x01   /* Special Error Check */

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <net/if.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <linux/can.h>
#include <linux/can/raw.h>

int main(void) {
    int s = socket(PF_CAN, SOCK_RAW, CAN_RAW);

    struct ifreq ifr;
    strcpy(ifr.ifr_name, "vcan0");
    ioctl(s, SIOCGIFINDEX, &ifr);

    struct sockaddr_can addr = {
        .can_family  = AF_CAN,
        .can_ifindex = ifr.ifr_ifindex,
    };
    bind(s, (struct sockaddr *)&addr, sizeof(addr));

    /* CAN XL frame desteğini etkinleştir */
    int enable_xl = 1;
    setsockopt(s, SOL_CAN_RAW, CAN_RAW_XL_FRAMES,
               &enable_xl, sizeof(enable_xl));

    /* CAN XL frame hazırla */
    struct canxl_frame xframe;
    memset(&xframe, 0, sizeof(xframe));

    xframe.prio  = 0x042 | CANXL_XLF;  /* öncelik=0x042, XL flag set */
    xframe.sdt   = 0x01;               /* SDU type (uygulama tanımlı) */
    xframe.len   = 128;                /* 128 byte payload */
    xframe.af    = 0x00010000;         /* VCID=1 (üst 8 bit) */

    for (int i = 0; i < 128; i++)
        xframe.data[i] = (uint8_t)i;

    ssize_t nbytes = write(s, &xframe, CANXL_MTU);
    if (nbytes != CANXL_MTU) {
        perror("write canxl");
        return 1;
    }
    printf("CAN XL frame gönderildi: PRIO=0x%03X SDT=0x%02X LEN=%d\n",
           xframe.prio & CAN_XL_PRIO_MASK, xframe.sdt, xframe.len);
    close(s);
    return 0;
}

# Kernel sürümünü kontrol et (6.2+ gerekli)
uname -r
# 6.6.31-1-rpi (Raspberry Pi için örnek)

# CAN XL header varlığını kontrol et
grep -r "CANXL_MTU" /usr/include/linux/can.h
# Yoksa güncel kernel-headers paketi yükle
sudo apt install linux-headers-$(uname -r)

# vcan modülü yükle (simülasyon için)
sudo modprobe vcan
sudo ip link add type vcan
sudo ip link set vcan0 mtu 2072  # CANXL_MTU + headroom
sudo ip link set vcan0 up

/* VCID — af alanının üst 8 biti */
#define VCID_POWERTRAIN  0x01
#define VCID_CHASSIS     0x02
#define VCID_INFOTAINMENT 0x03

static inline void set_vcid(struct canxl_frame *f, uint8_t vcid) {
    f->af = (f->af & 0x00FFFFFF) | ((uint32_t)vcid << 24);
}

static inline uint8_t get_vcid(const struct canxl_frame *f) {
    return (uint8_t)(f->af >> 24);
}

/* Kullanım: powertrain verisi gönder */
xframe.prio = 0x100 | CANXL_XLF;
xframe.sdt  = 0x02;              /* uygulama verisi */
set_vcid(&xframe, VCID_POWERTRAIN);
xframe.len  = 64;

#include <linux/can.h>
#include <linux/can/raw.h>
#include <string.h>

void prepare_canxl_frame(struct canxl_frame *xf,
                          uint16_t prio, uint8_t vcid,
                          uint8_t sdt, const void *payload,
                          uint16_t payload_len)
{
    memset(xf, 0, sizeof(*xf));

    xf->prio = (prio & CAN_XL_PRIO_MASK) | CANXL_XLF;
    xf->sdt  = sdt;
    xf->len  = payload_len;
    xf->af   = (uint32_t)vcid << 24;   /* VCID üst 8 bit */

    if (payload_len > 0 && payload_len <= CANXL_MAX_DLEN)
        memcpy(xf->data, payload, payload_len);
}

/* socket seçeneği */
int enable_xl = 1;
setsockopt(s, SOL_CAN_RAW, CAN_RAW_XL_FRAMES,
           &enable_xl, sizeof(enable_xl));

/* Gönderme — CANXL_MTU = 2060 byte */
struct canxl_frame xf;
prepare_canxl_frame(&xf, 0x042, 0x01, 0x04,
                    ip_packet, ip_packet_len);
write(s, &xf, CANXL_MTU);

# can-utils güncel sürümde CAN XL frame gösterimi
# CAN XL çıktı formatı:
# (timestamp) vcan0  042#XL#01#01#00010000#0001020304...
#                    prio  XL sdt  af(vcid)    data

candump vcan0

# cansend ile CAN XL (can-utils 2022.02.0+)
# Syntax: ID#XL#SDT#FLAGS#AF#DATA
cansend vcan0 042#XL#01#00#00010000#0102030405060708

# vcan kernel modülü yükle
sudo modprobe vcan

# CAN XL destekli vcan arayüzü oluştur
# MTU 2072 = CANXL_MTU(2060) + headroom
sudo ip link add dev vcan0 type vcan
sudo ip link set vcan0 mtu 2072
sudo ip link set vcan0 up

# İkinci vcan (iki node simülasyonu)
sudo ip link add dev vcan1 type vcan
sudo ip link set vcan1 mtu 2072
sudo ip link set vcan1 up

# Arayüz durumu
ip link show vcan0

# Rastgele CAN frame üret (saniyede 1000 frame)
cangen vcan0 -g 1 -i -e

# Sabit ID ve veri boyutuyla test
cangen vcan0 -g 5 -I 0x100 -L 8

# Paralel terminalde izle
candump vcan0

# tcpdump ile pcap kaydı
tcpdump -i vcan0 -w /tmp/canxl_capture.pcap

# Wireshark — CAN XL dissector (3.6+)
wireshark -i vcan0 -k

# candump log formatına kaydet ve sonra analiz
candump -l vcan0
# candump-YYYY-MM-DD_HHMMSS.log dosyası oluşturulur

import socket, struct, ctypes

# Linux canxl_frame struct (Python ctypes ile)
class CanxlFrame(ctypes.Structure):
    _fields_ = [
        ('prio',  ctypes.c_uint32),  # 11-bit öncelik + CANXL_XLF
        ('flags', ctypes.c_uint8),
        ('sdt',   ctypes.c_uint8),
        ('len',   ctypes.c_uint16),
        ('af',    ctypes.c_uint32),
        ('data',  ctypes.c_uint8 * 2048),
    ]

CANXL_XLF     = 0x80000000
SDU_TYPE_IPV4 = 0x04
CANXL_MTU     = ctypes.sizeof(CanxlFrame)  # 2060

def send_ip_over_canxl(can_sock, ip_packet: bytes, vcid: int = 0x01):
    assert len(ip_packet) <= 2048, "IP paketi 2048 byte'ı aşamaz"

    frame = CanxlFrame()
    frame.prio  = 0x010 | CANXL_XLF   # öncelik = 0x010
    frame.sdt   = SDU_TYPE_IPV4
    frame.len   = len(ip_packet)
    frame.af    = vcid << 24           # VCID üst 8 bit

    ctypes.memmove(frame.data, ip_packet, len(ip_packet))

    sent = can_sock.send(bytes(frame)[:CANXL_MTU])
    print(ff"Gönderildi: {sent} byte (IP payload {len(ip_packet)} byte)")

# Socket oluştur
s = socket.socket(socket.AF_CAN, socket.SOCK_RAW, socket.CAN_RAW)

# CAN XL etkinleştir
CAN_RAW_XL_FRAMES = 7  # Linux 6.2+
s.setsockopt(socket.SOL_CAN_RAW, CAN_RAW_XL_FRAMES, 1)

s.bind(('vcan0',))

# Örnek IP paketi (sahte, gerçek IP header değil)
fake_ip_pkt = b'\x45\x00' + b'\x00' * 18 + b'\xDE\xAD\xBE\xEF' * 10
send_ip_over_canxl(s, fake_ip_pkt, vcid=0x01)
s.close()