Translation

void	ce_gw_can2net (struct sk_buff *eth_skb, struct sk_buff *can_skb, struct net_device *eth_dev, struct net_device *can_dev, unsigned char *mac_dst, unsigned char *mac_src)
	for CE_GW_TYPE_NET: copy CAN-Frame into ethernet payload More...
struct sk_buff *	ce_gw_can2net_alloc (struct sk_buff *can_skb, struct net_device *eth_dev, struct net_device *can_dev, unsigned char *mac_dst, unsigned char *mac_src)
	for CE_GW_TYPE_NET: copy CAN-Frame into ethernet payload and allocate More...
struct sk_buff *	ce_gw_net2can_alloc (struct sk_buff *eth_skb, struct net_device *can_dev)
	for CE_GW_TYPE_NET: Copy the can-frame from eth_skb to a new can skb. More...
void	ce_gw_canfd2net (struct sk_buff *eth_skb, struct sk_buff *can_skb, struct net_device *eth_dev, struct net_device *can_dev, unsigned char *mac_dst, unsigned char *mac_src)
	for CE_GW_TYPE_NET: copy CAN-Frame into ethernet payload More...
struct sk_buff *	ce_gw_canfd2net_alloc (struct sk_buff *can_skb, struct net_device *eth_dev, struct net_device *can_dev, unsigned char *mac_dst, unsigned char *mac_src)
	for CE_GW_TYPE_NET: copy canfd-Frame into ethernet payload and allocate More...
struct sk_buff *	ce_gw_net2canfd_alloc (struct sk_buff *eth_skb, struct net_device *can_dev, struct net_device *eth_dev)
	for CE_GW_TYPE_NET: Copy the canfd-frame from eth_skb to a new can skb. More...
struct sk_buff *	ce_gw_can_to_eth (unsigned char *dest, unsigned char *source, __be16 type, struct sk_buff *can_buffer, struct net_device *dev)
	converts sk buffer including can frame into sk buffer including ethernet_frame More...
struct sk_buff *	ce_gw_canfd_to_eth (unsigned char *dest, unsigned char *source, __be16 type, struct sk_buff *canfd_skb, struct net_device *dev)
	converts sk buffer including canfd frame into sk buffer including ethernet frame More...
struct sk_buff *	ce_gw_eth_to_can (canid_t id, struct sk_buff *eth_buff, struct net_device *dev)
	converst sk_buffer including an ethernet frame to sk_buffer including a can_frame More...
struct sk_buff *	ce_gw_eth_to_canfd (canid_t id, __u8 flags, __u8 res0, __u8 res1, struct sk_buff *eth_skb, struct net_device *dev)
	converst sk buffer including an ethernet frame to sk buffer including a canfd frame More...

Detailed Description

Function Documentation

void ce_gw_can2net	(	struct sk_buff *	eth_skb,
		struct sk_buff *	can_skb,
		struct net_device *	eth_dev,
		struct net_device *	can_dev,
		unsigned char *	mac_dst,
		unsigned char *	mac_src
	)

for CE_GW_TYPE_NET: copy CAN-Frame into ethernet payload

Parameters

eth_skb	The sk_buff where the frame should copy to. Must be already allocated and must have sizeof(struct ethhdr) + sizeof(struct can_frame) headroom.
can_skb	The sk_buff where the can-frame is located.
eth_dev	The device which will later redirect the eth_skb. (this function does not redirect)
can_dev	The device where can_skb was received.
mac_dst	The dest MAC Address for the eth_skb.
mac_src	The source MAC Address for the eth_skb

Warning

you must free can_skb yourself

It create an ethernet header in the empty param eth_skb and copy the can-frame from param can_skb as an an network layer protocol into the payload. It sets the layer pointer and the ethernet type.

Definition at line 240 of file ce_gw_main.c.

Referenced by ce_gw_can2net_alloc(), and ce_gw_canfd2net_alloc().

{
#   ifdef NET_SKBUFF_DATA_USES_OFFSET
#   else /* NET_SKBUFF_DATA_USES_OFFSET */
#   endif /* NET_SKBUFF_DATA_USES_OFFSET */

    /* set transport to data. if data == tail (what normally should be)
     * that means there is no transport layer */
    skb_set_transport_header(eth_skb, 0);

    /* network layer */
    struct can_frame *eth_canf;
    eth_canf = (struct can_frame *)skb_push(
                       eth_skb, sizeof(struct can_frame));
    skb_set_network_header(eth_skb, 0);

    struct can_frame *can_canf;
    can_canf = (struct can_frame *) can_skb->data;

    memcpy(eth_canf, can_canf, sizeof(struct can_frame));

    /* hardware layer */
    struct ethhdr *eth_ethh;
    eth_ethh = (struct ethhdr *)skb_push(eth_skb, sizeof(struct ethhdr));
    skb_set_mac_header(eth_skb, 0);

    memcpy(eth_ethh->h_dest, mac_dst , ETH_ALEN);
    memcpy(eth_ethh->h_source, mac_src, ETH_ALEN);
    eth_ethh->h_proto = htons(ETH_P_CAN);
}

Here is the caller graph for this function:

struct sk_buff * ce_gw_can2net_alloc ( struct sk_buff *  can_skb, struct net_device *  eth_dev, struct net_device *  can_dev, unsigned char *  mac_dst, unsigned char *  mac_src  )

read

for CE_GW_TYPE_NET: copy CAN-Frame into ethernet payload and allocate

Parameters

can_skb	The sk_buff where the can-frame is located.
eth_dev	The device which will redirect the eth_skb.
can_dev	The device where can_skb was received.
mac_dst	The dest MAC Address for the eth_skb.
mac_src	The source MAC Address for the eth_skb

Warning

you must free can_skb yourself

Return values

NULL	if an error occured
sk_buff	An allocated sk_buff with an ethernet header and the can frame as payload.

It create an ethernet header in a new sk_buff and copy the can-frame from param can_skb as an an network layer protocol into the payload. It allocates a new socket buffer and sets some default skb settings. The returned sk_buff will be set to a PACKET_BROADCAST.

Definition at line 295 of file ce_gw_main.c.

References ce_gw_can2net().

Referenced by ce_gw_can_rcv().

                                                            {
    int err;
    struct sk_buff *eth_skb;
    eth_skb = netdev_alloc_skb(eth_dev, sizeof(struct ethhdr) +
                               sizeof(struct can_frame));
    if (eth_skb == NULL) {
        err = -ENOMEM;
        pr_err("ce_gw: Error during ce_gw_can2net_alloc: %d\n", err);
        return NULL;
    }

    skb_reserve(eth_skb, sizeof(struct ethhdr) + sizeof(struct can_frame));
    /* On CAN only broatcast possible */
    eth_skb->pkt_type = PACKET_BROADCAST;
    ce_gw_can2net(eth_skb, can_skb, eth_dev, can_dev, mac_dst, mac_src);

    return eth_skb;

ce_gw_can2net_alloc_error:
    kfree_skb(eth_skb);
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct sk_buff * ce_gw_can_to_eth ( unsigned char *  dest, unsigned char *  source, __be16  type, struct sk_buff *  can_buffer, struct net_device *  dev  )

read

converts sk buffer including can frame into sk buffer including ethernet_frame

Parameters

dest	MAC address of destination
source	MAC address of source
type	type of layer3 message (example: ipv4 or ipv6 ...)
can_buffer	sk buffer including a can frame
dev	device of destination

Return values

sk_buffer	on success including ethernet frame
NULL	if unsuccessful

Todo:

not tested yet

Definition at line 533 of file ce_gw_main.c.

                                                  {
    struct can_frame *can_frame_skb = (struct can_frame *)
                                      can_buffer->data;
    struct ethhdr *ethhdr;
    u8 canlen = can_dlc2len(can_frame_skb->can_dlc);
    struct sk_buff *eth_skb = dev_alloc_skb(sizeof(struct ethhdr) + sizeof
                                            (struct can_frame) + 64);
    if (eth_skb == NULL) {
        printk (KERN_ERR "ce_gw_main.c: kmalloc failed in function"
                "ce_gw_can_to_eth \n");
        return NULL;
    }
    eth_skb->dev = dev;

    /*updates data pointer to tail */
    skb_reserve(eth_skb, sizeof(struct ethhdr) + sizeof(struct can_frame) +
                64);
    /*updates data pointer to start of network header*/
    eth_skb->data = skb_push(eth_skb, (const int) canlen);

    /*copys data from can sk buffer into ethernet sk buffer */
    memcpy(eth_skb->data, can_buffer->data + sizeof(struct can_frame) -
           - canlen, canlen);
    /*update network_header */
    skb_set_network_header(eth_skb, 0);
    /*updates transport header */
    skb_set_transport_header(eth_skb, (const int) canlen);

    /*updates data pointer to mac header */
    eth_skb->data = skb_push(eth_skb, (const int) sizeof(struct ethhdr));
    /*updates mac_header*/
    skb_set_mac_header(eth_skb, 0);
    /*fills ethhdr with data */
    ethhdr = eth_hdr(eth_skb);
    memcpy(ethhdr->h_dest, dest, ETH_ALEN);
    memcpy(ethhdr->h_source, source, ETH_ALEN);
    ethhdr->h_proto = type;

    return eth_skb;
}

void ce_gw_canfd2net	(	struct sk_buff *	eth_skb,
		struct sk_buff *	can_skb,
		struct net_device *	eth_dev,
		struct net_device *	can_dev,
		unsigned char *	mac_dst,
		unsigned char *	mac_src
	)

for CE_GW_TYPE_NET: copy CAN-Frame into ethernet payload

Parameters

eth_skb	The sk_buff where the frame should copy to. Must be already allocated and must have sizeof(struct ethhdr) + sizeof(struct can_frame) headroom.
can_skb	The sk_buff where the canfd-frame is located.
eth_dev	The device which will later redirect the eth_skb. (this function does not redirect)
can_dev	The device where can_skb was received.
mac_dst	The dest MAC Address for the eth_skb.
mac_src	The source MAC Address for the eth_skb

Warning

you must free can_skb yourself

Todo:

not tested yet but its the same as ce_gw_can2net()

It create an ethernet header in the empty param eth_skb and copy the canfd-frame from param can_skb as an an network layer protocol into the payload. It sets the layer pointer and the ethernet type.

Definition at line 387 of file ce_gw_main.c.

{
#   ifdef NET_SKBUFF_DATA_USES_OFFSET
#   else /* NET_SKBUFF_DATA_USES_OFFSET */
#   endif /* NET_SKBUFF_DATA_USES_OFFSET */

    /* set transport to data. if data == tail (what normally should be)
     * that means there is no transport layer */
    skb_set_transport_header(eth_skb, 0);

    /* network layer */
    struct canfd_frame *eth_canf;
    eth_canf = (struct canfd_frame *)skb_push(
                       eth_skb, sizeof(struct canfd_frame));
    skb_set_network_header(eth_skb, 0);

    struct canfd_frame *can_canf;
    can_canf = (struct canfd_frame *) can_skb->data;

    memcpy(eth_canf, can_canf, sizeof(struct canfd_frame));

    /* hardware layer */
    struct ethhdr *eth_ethh;
    eth_ethh = (struct ethhdr *)skb_push(eth_skb, sizeof(struct ethhdr));
    skb_set_mac_header(eth_skb, 0);

    memcpy(eth_ethh->h_dest, mac_dst, ETH_ALEN);
    memcpy(eth_ethh->h_source, mac_src, ETH_ALEN);
    eth_ethh->h_proto = htons(ETH_P_CANFD);
}

struct sk_buff * ce_gw_canfd2net_alloc ( struct sk_buff *  can_skb, struct net_device *  eth_dev, struct net_device *  can_dev, unsigned char *  mac_dst, unsigned char *  mac_src  )

read

for CE_GW_TYPE_NET: copy canfd-Frame into ethernet payload and allocate

Parameters

can_skb	The sk_buff where the canfd-frame is located.
eth_dev	The device which will redirect the eth_skb.
can_dev	The device where can_skb was received.
mac_dst	The dest MAC Address for the eth_skb.
mac_src	The source MAC Address for the eth_skb

Warning

you must free can_skb yourself

Return values

NULL	if an error occured
sk_buff	An allocated sk_buff with an ethernet header and the can frame as payload.

It create an ethernet header in a new sk_buff and copy the canfd-frame from param can_skb as an an network layer protocol into the payload. It allocates a new socket buffer and sets some default skb settings. The returned sk_buff will be set to a PACKET_BROADCAST.

Todo:

not tested yet but its the same as ce_gw_can2net_alloc()

Definition at line 444 of file ce_gw_main.c.

References ce_gw_can2net().

                                                              {
    int err;
    struct sk_buff *eth_skb;
    eth_skb = netdev_alloc_skb(eth_dev, sizeof(struct ethhdr) +
                               sizeof(struct canfd_frame));
    if (eth_skb == NULL) {
        err = -ENOMEM;
        pr_err("ce_gw: Allocation failed: %d\n", err);
        return NULL;
    }

    skb_reserve(eth_skb, sizeof(struct ethhdr) +
                sizeof(struct canfd_frame));
    eth_skb->pkt_type = PACKET_BROADCAST;

    ce_gw_can2net(eth_skb, can_skb, eth_dev, can_dev, mac_dst, mac_src);
    return eth_skb;

ce_gw_can2net_alloc_error:
    kfree_skb(eth_skb);
    return NULL;
}

Here is the call graph for this function:

struct sk_buff * ce_gw_canfd_to_eth ( unsigned char *  dest, unsigned char *  scource, __be16  type, struct sk_buff *  canfd_skb, struct net_device *  dev  )

read

converts sk buffer including canfd frame into sk buffer including ethernet frame

Parameters

dest	MAC address of destination
source	MAC address of source
type	type of layer3 message (example: ipv4 or ipv6 ...)
canfd_skb	sk buffer including a canfd_frame
dev	device of the destination

Return values

sk_buff	including ethernet frame if successful
NULL	if unsuccessful

Todo:

not tested yet

Definition at line 577 of file ce_gw_main.c.

                                                           {
    struct sk_buff *eth_skb = dev_alloc_skb(sizeof(struct ethhdr) +
                                            sizeof(struct canfd_frame) + 64);
    if (eth_skb == NULL) {
        printk (KERN_ERR "ce_gw_main.c: kmalloc failed in function"
                "ce_gw_canfd_to_eth \n");
        return NULL;
    }
    struct ethhdr *ethhdr;
    struct canfd_frame *canfd_frame_skb = (struct canfd_frame *)
                                          canfd_skb->data;
    u8 canlen = can_dlc2len(canfd_frame_skb->len);
    unsigned int iplen = ip_hdrlen(canfd_skb);
    eth_skb->dev = dev;

    /*updates data pointer to tail */
    skb_reserve(eth_skb, sizeof(struct ethhdr) + sizeof(struct canfd_frame)
                + 64);
    /*updates data pointer to start of network header*/
    eth_skb->data = skb_push(eth_skb, (const int) canlen);

    /*copys data from canfd sk buffer into ethernet sk buffer */
    memcpy(eth_skb->data, canfd_skb->data + sizeof(struct canfd_frame) -
           sizeof(__u8)*64, canlen);
    /*update network_header */
    skb_set_network_header(eth_skb, 0);
    /*updates transport header */
    if (canlen >= iplen) {
        skb_set_transport_header(eth_skb, (const int) iplen);
    } else {
        skb_set_transport_header(eth_skb, (const int) sizeof(__u8)*64);
    }
    /*updates data pointer to start of mac header*/
    eth_skb->data = skb_push(eth_skb, (const int) sizeof(struct ethhdr));
    /*updates mac_header*/
    skb_set_mac_header(eth_skb, 0);
    /*fills eth_skb with data*/
    ethhdr = eth_hdr(eth_skb);
    memcpy(ethhdr->h_dest, &dest, ETH_ALEN);
    memcpy(ethhdr->h_source, &source, ETH_ALEN);
    ethhdr->h_proto = type;

    return eth_skb;
}

struct sk_buff * ce_gw_eth_to_can ( canid_t  id, struct sk_buff *  eth_buff, struct net_device *  dev  )

read

converst sk_buffer including an ethernet frame to sk_buffer including a can_frame

Parameters

id	identifier of can_frame (see ce_gw_get_header for more information
eth_buff	sk_buffer including an ethernet frame
dev	device of the destination

Returns

sk_buffer including a can frame

Todo:

not tested yet

Definition at line 625 of file ce_gw_main.c.

References ce_gw_alloc_can_frame(), and ce_gw_free_can_frame().

                                                  {
    struct sk_buff *can_buff;
    struct can_frame *can = ce_gw_alloc_can_frame();
    if (can == NULL) {
        printk (KERN_ERR "ce_gw_main.c: kmalloc failed in function"
                "ce_gw_eth_to_can \n");
        return NULL;
    }
    unsigned int ethdatalen = (skb_tail_pointer(eth_buff) - (eth_buff->data
                               + sizeof(struct ethhdr)));
    /* unsigned int iplen = ip_hdrlen(eth_buff); */

    /*fills can header */
    can->can_id = id;
    can->can_dlc = (__u8) eth_buff->data_len - sizeof(struct ethhdr);

    can_buff = dev_alloc_skb(sizeof(struct can_frame) + ethdatalen + 64);
    if (can_buff == NULL) {
        printk (KERN_ERR "ce_gw_main.c: kmalloc failed in function"
                "ce_gw_eth_to_can \n");
        return NULL;
    }
    can_buff->dev = dev;

    /*updates data pointer to tail */
    skb_reserve(can_buff, sizeof(struct can_frame) + ethdatalen + 64);
    /*updates data pointer to start of network header*/
    can_buff->data = skb_push(can_buff, (const int) ethdatalen);

    /*copys data from ethernet sk buffer into can buffer */
    memcpy(can_buff->data, eth_buff->data + sizeof(struct ethhdr),
           sizeof(u64));
    /*update network_header */
    skb_set_network_header(can_buff, 0);
    /*updates transport header */
    skb_set_transport_header(can_buff, (const int) sizeof(u64));

    /*updates data pointer to start of mac header */
    can_buff->data = skb_push(can_buff, (const int) sizeof(__u32) +
                              sizeof(__u8));
    /*updates mac header */
    skb_set_mac_header(can_buff, 0);
    /*copys can header at the beginning of sk buffer */
    memcpy(skb_mac_header(can_buff), &can->can_id, sizeof(__u32) +
           sizeof(__u8));

    ce_gw_free_can_frame(can);

    return can_buff;
}

Here is the call graph for this function:

struct sk_buff * ce_gw_eth_to_canfd ( canid_t  id, __u8  flags, __u8  res0, __u8  res1, struct sk_buff *  eth_skb, struct net_device *  dev  )

read

converst sk buffer including an ethernet frame to sk buffer including a canfd frame

Parameters

id	identifier of canfd (see ce_gw_get_canfd_header for more information)
flags	additional flags for CAN FD
res0	reserved / padding
res1	reserved / padding
eth_skb	sk buffer including ethernet frame
dev	device of the destination

Returns

sk buffer including canfd frame

Todo:

not tested yet

Definition at line 678 of file ce_gw_main.c.

References ce_gw_alloc_canfd_frame(), and ce_gw_free_canfd_frame().

                                                    {
    struct sk_buff *canfd_skb;
    struct canfd_frame *canfd = ce_gw_alloc_canfd_frame();
    if (canfd == NULL) {
        printk (KERN_ERR "ce_gw_main.c: kmalloc failed in function"
                "ce_gw_eth_to_canfd \n");
        return NULL;
    }
    /* unsigned int ethdatalen = (skb_tail_pointer(eth_skb) - (eth_skb->data
                               + sizeof(struct ethhdr))); */
    unsigned int iplen = ip_hdrlen(eth_skb);

    /*fills canfd header */
    canfd->can_id = id;
    canfd->flags = flags;
    canfd->__res0 = res0;
    canfd->__res1 = res1;
    canfd->len = (__u8) eth_skb->data_len - sizeof(struct ethhdr);

    canfd_skb = dev_alloc_skb(sizeof(struct canfd_frame) + 64);
    if (canfd_skb == NULL) {
        printk (KERN_ERR "ce_gw_main.c: kmalloc failed in function"
                "ce_gw_eth_to_canfd \n");
        return NULL;
    }
    canfd_skb->dev = dev;

    /*updates data pointer to tail */
    skb_reserve(canfd_skb, sizeof(struct canfd_frame) + 64);
    /*updates data pointer to start of network header*/
    canfd_skb->data = skb_push(canfd_skb, (const int) sizeof(__u8)*64);

    /*copys data from ethernet sk buffer into canfd sk buffer */
    memcpy(canfd_skb->data, eth_skb->data + sizeof(struct ethhdr),
           sizeof(__u8)*64);
    /*update network_header */
    skb_set_network_header(canfd_skb, 0);
    /*checks if can data length >= iplen*/
    /*updates transport header */
    if (sizeof(__u8)*64 >= iplen) {
        skb_set_transport_header(canfd_skb, (const int) iplen);
    } else {
        skb_set_transport_header(canfd_skb, sizeof(__u8)*64);
    }
    /*updates data pointer to start of mac header */
    canfd_skb->data = skb_push(canfd_skb, (const int) sizeof(struct
                               canfd_frame) - sizeof(__u8)*64);
    /*updates mac header */
    skb_set_mac_header(canfd_skb, 0);
    /*copys canfd header into sk buffer */
    memcpy(skb_mac_header(canfd_skb), &canfd->can_id, sizeof(struct
                    canfd_frame) - sizeof(__u8)*64);
    ce_gw_free_canfd_frame(canfd);

    return canfd_skb;
}

Here is the call graph for this function:

struct sk_buff * ce_gw_net2can_alloc ( struct sk_buff *  eth_skb, struct net_device *  can_dev  )

read

for CE_GW_TYPE_NET: Copy the can-frame from eth_skb to a new can skb.

Parameters

eth_skb	An ethernet header as hardware layer and a can-frame as network layer.
can_dev	CAN net device where the package will be later redirect to (this function does not redirect)

Warning

you must free eth_skb yourself

Return values

NULL	on error
sk_buff	on success including can-frame

Copy the can-frame from the network layer in eth_skb to hardware layer in a new sk_buff. This Function allocates a new sk_buff and set some settings. The returned sk_buff will be set to a PACKET_BROADCAST.

Definition at line 338 of file ce_gw_main.c.

Referenced by ce_gw_eth_rcv().

                                                                {
    int err;

    /* No transport layer */
    /* No network layer */

    /* hardware (mac) layer */
    struct sk_buff *can_skb;
    /* canf is the pointer where you can later copy the data to buffer */
    struct can_frame *canf;
    can_skb = alloc_can_skb(can_dev, &canf);
    if (!can_skb) {
        err = -ENOMEM;
        pr_err("ce_gw: Allocation failed: %d\n", err);
        goto ce_gw_net2can_alloc_error;
    }

    /* Get Can frame at network layer start */
    memcpy(canf, skb_network_header(eth_skb), sizeof(struct can_frame));

    return can_skb;

ce_gw_net2can_alloc_error:
    kfree_skb(can_skb);
    return NULL;
}

Here is the caller graph for this function:

struct sk_buff * ce_gw_net2canfd_alloc ( struct sk_buff *  eth_skb, struct net_device *  can_dev, struct net_device *  eth_dev  )

read

for CE_GW_TYPE_NET: Copy the canfd-frame from eth_skb to a new can skb.

Parameters

eth_skb	An ethernet header as hardware layer and a canfd-frame as network layer.
can_dev	CAN net device where the package will be later redirect to (this function does not redirect)

Warning

you must free eth_skb yourself

Return values

NULL	on error
sk_buff	on success including canfd-frame

Copy the canfd-frame from the network layer in eth_skb to hardware layer in a new sk_buff. This Function allocates a new sk_buff and set some settings. The returned sk_buff will be set to a PACKET_BROADCAST.

Todo:

not tested yet.

there might be a better way to allocted the new skb.

Definition at line 490 of file ce_gw_main.c.

                                                                  {
    int err;

    /* No transport layer */
    /* No network layer */

    /* hardware layer */
    struct sk_buff *can_skb;
    /* canf is the pointer where you can later copy the data to buffer */
    struct can_frame *canf;
    can_skb = alloc_can_skb(can_dev, &canf);
    if (can_skb == NULL) {
        err = -ENOMEM;
        pr_err("ce_gw: Allocation failed: %d\n", err);
        goto ce_gw_net2can_alloc_error;
    }

    /* expand the sk_buff because alloc_can_skb only allocates space for
     * an can_frame and not the larger canfd_frame. So it will be
     * expanded by the difference
     * TODO This is quite a bad idea but there is no alloc_can_skb function
     * for canfd_frame. Anyway there might exist a better way */
    skb_copy_expand(can_skb, 0, sizeof(struct canfd_frame) -
                    sizeof(struct can_frame), GFP_ATOMIC);
    skb_put(can_skb, sizeof(struct canfd_frame) - sizeof(struct can_frame));
    can_skb->protocol = htons(ETH_P_CANFD);

    struct canfd_frame *canfdf;
    canfdf = (struct canfd_frame *) canf;

    /* copy canfd_frame */
    memcpy(canfdf, skb_network_header(eth_skb), sizeof(struct canfd_frame));

    return can_skb;

ce_gw_net2can_alloc_error:
    kfree_skb(can_skb);
    return NULL;
}