can: skb: unify skb CAN frame identification helpers

Replace open coded checks for sk_buffs containing Classical CAN and
CAN FD frame structures as a preparation for CAN XL support.

With the added length check the unintended processing of CAN XL frames
having the CANXL_XLF bit set can be suppressed even when the skb->len
fits to non CAN XL frames.

The CAN_RAW socket needs a rework to use these helpers. Therefore the
use of these helpers is postponed to the CAN_RAW CAN XL integration.

The J1939 protocol gets a check for Classical CAN frames too.

Acked-by: Vincent Mailhol <mailhol.vincent@wanadoo.fr>
Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>
Link: https://lore.kernel.org/all/20220912170725.120748-2-socketcan@hartkopp.net
Signed-off-by: Marc Kleine-Budde <mkl@pengutronix.de>

diff --git a/drivers/net/can/dev/skb.c b/drivers/net/can/dev/skb.c
index 07e0fea..f457c94 100644 (file)
--- a/drivers/net/can/dev/skb.c
+++ b/drivers/net/can/dev/skb.c
@@ -299,18 +299,20 @@ static bool can_skb_headroom_valid(struct net_device *dev, struct sk_buff *skb)
 /* Drop a given socketbuffer if it does not contain a valid CAN frame. */
 bool can_dropped_invalid_skb(struct net_device *dev, struct sk_buff *skb)
 {
-       const struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
        struct can_priv *priv = netdev_priv(dev);
 
-       if (skb->protocol == htons(ETH_P_CAN)) {
-               if (unlikely(skb->len != CAN_MTU ||
-                            cfd->len > CAN_MAX_DLEN))
+       switch (ntohs(skb->protocol)) {
+       case ETH_P_CAN:
+               if (!can_is_can_skb(skb))
                        goto inval_skb;
-       } else if (skb->protocol == htons(ETH_P_CANFD)) {
-               if (unlikely(skb->len != CANFD_MTU ||
-                            cfd->len > CANFD_MAX_DLEN))
+               break;
+
+       case ETH_P_CANFD:
+               if (!can_is_canfd_skb(skb))
                        goto inval_skb;
-       } else {
+               break;
+
+       default:
                goto inval_skb;
        }
 

diff --git a/include/linux/can/skb.h b/include/linux/can/skb.h
index 182749e..27ebfc2 100644 (file)
--- a/include/linux/can/skb.h
+++ b/include/linux/can/skb.h
@@ -97,10 +97,20 @@ static inline struct sk_buff *can_create_echo_skb(struct sk_buff *skb)
        return nskb;
 }
 
+static inline bool can_is_can_skb(const struct sk_buff *skb)
+{
+       struct can_frame *cf = (struct can_frame *)skb->data;
+
+       /* the CAN specific type of skb is identified by its data length */
+       return (skb->len == CAN_MTU && cf->len <= CAN_MAX_DLEN);
+}
+
 static inline bool can_is_canfd_skb(const struct sk_buff *skb)
 {
+       struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
+
        /* the CAN specific type of skb is identified by its data length */
-       return skb->len == CANFD_MTU;
+       return (skb->len == CANFD_MTU && cfd->len <= CANFD_MAX_DLEN);
 }
 
 #endif /* !_CAN_SKB_H */

diff --git a/net/can/af_can.c b/net/can/af_can.c
index 1fb49d5..afa6c21 100644 (file)
--- a/net/can/af_can.c
+++ b/net/can/af_can.c
@@ -199,27 +199,19 @@ static int can_create(struct net *net, struct socket *sock, int protocol,
 int can_send(struct sk_buff *skb, int loop)
 {
        struct sk_buff *newskb = NULL;
-       struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
        struct can_pkg_stats *pkg_stats = dev_net(skb->dev)->can.pkg_stats;
        int err = -EINVAL;
 
-       if (skb->len == CAN_MTU) {
+       if (can_is_can_skb(skb)) {
                skb->protocol = htons(ETH_P_CAN);
-               if (unlikely(cfd->len > CAN_MAX_DLEN))
-                       goto inval_skb;
-       } else if (skb->len == CANFD_MTU) {
+       } else if (can_is_canfd_skb(skb)) {
                skb->protocol = htons(ETH_P_CANFD);
-               if (unlikely(cfd->len > CANFD_MAX_DLEN))
-                       goto inval_skb;
        } else {
                goto inval_skb;
        }
 
-       /* Make sure the CAN frame can pass the selected CAN netdevice.
-        * As structs can_frame and canfd_frame are similar, we can provide
-        * CAN FD frames to legacy CAN drivers as long as the length is <= 8
-        */
-       if (unlikely(skb->len > skb->dev->mtu && cfd->len > CAN_MAX_DLEN)) {
+       /* Make sure the CAN frame can pass the selected CAN netdevice. */
+       if (unlikely(skb->len > skb->dev->mtu)) {
                err = -EMSGSIZE;
                goto inval_skb;
        }
@@ -678,53 +670,31 @@ static void can_receive(struct sk_buff *skb, struct net_device *dev)
 static int can_rcv(struct sk_buff *skb, struct net_device *dev,
                   struct packet_type *pt, struct net_device *orig_dev)
 {
-       struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
-
-       if (unlikely(dev->type != ARPHRD_CAN || skb->len != CAN_MTU)) {
+       if (unlikely(dev->type != ARPHRD_CAN || (!can_is_can_skb(skb)))) {
                pr_warn_once("PF_CAN: dropped non conform CAN skbuff: dev type %d, len %d\n",
                             dev->type, skb->len);
-               goto free_skb;
-       }
 
-       /* This check is made separately since cfd->len would be uninitialized if skb->len = 0. */
-       if (unlikely(cfd->len > CAN_MAX_DLEN)) {
-               pr_warn_once("PF_CAN: dropped non conform CAN skbuff: dev type %d, len %d, datalen %d\n",
-                            dev->type, skb->len, cfd->len);
-               goto free_skb;
+               kfree_skb(skb);
+               return NET_RX_DROP;
        }
 
        can_receive(skb, dev);
        return NET_RX_SUCCESS;
-
-free_skb:
-       kfree_skb(skb);
-       return NET_RX_DROP;
 }
 
 static int canfd_rcv(struct sk_buff *skb, struct net_device *dev,
                     struct packet_type *pt, struct net_device *orig_dev)
 {
-       struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
-
-       if (unlikely(dev->type != ARPHRD_CAN || skb->len != CANFD_MTU)) {
+       if (unlikely(dev->type != ARPHRD_CAN || (!can_is_canfd_skb(skb)))) {
                pr_warn_once("PF_CAN: dropped non conform CAN FD skbuff: dev type %d, len %d\n",
                             dev->type, skb->len);
-               goto free_skb;
-       }
 
-       /* This check is made separately since cfd->len would be uninitialized if skb->len = 0. */
-       if (unlikely(cfd->len > CANFD_MAX_DLEN)) {
-               pr_warn_once("PF_CAN: dropped non conform CAN FD skbuff: dev type %d, len %d, datalen %d\n",
-                            dev->type, skb->len, cfd->len);
-               goto free_skb;
+               kfree_skb(skb);
+               return NET_RX_DROP;
        }
 
        can_receive(skb, dev);
        return NET_RX_SUCCESS;
-
-free_skb:
-       kfree_skb(skb);
-       return NET_RX_DROP;
 }
 
 /* af_can protocol functions */

diff --git a/net/can/bcm.c b/net/can/bcm.c
index e60161b..e5d179b 100644 (file)
--- a/net/can/bcm.c
+++ b/net/can/bcm.c
@@ -648,8 +648,13 @@ static void bcm_rx_handler(struct sk_buff *skb, void *data)
                return;
 
        /* make sure to handle the correct frame type (CAN / CAN FD) */
-       if (skb->len != op->cfsiz)
-               return;
+       if (op->flags & CAN_FD_FRAME) {
+               if (!can_is_canfd_skb(skb))
+                       return;
+       } else {
+               if (!can_is_can_skb(skb))
+                       return;
+       }
 
        /* disable timeout */
        hrtimer_cancel(&op->timer);

diff --git a/net/can/gw.c b/net/can/gw.c
index 1ea4cc5..23a3d89 100644 (file)
--- a/net/can/gw.c
+++ b/net/can/gw.c
@@ -463,10 +463,10 @@ static void can_can_gw_rcv(struct sk_buff *skb, void *data)
 
        /* process strictly Classic CAN or CAN FD frames */
        if (gwj->flags & CGW_FLAGS_CAN_FD) {
-               if (skb->len != CANFD_MTU)
+               if (!can_is_canfd_skb(skb))
                        return;
        } else {
-               if (skb->len != CAN_MTU)
+               if (!can_is_can_skb(skb))
                        return;
        }
 

diff --git a/net/can/isotp.c b/net/can/isotp.c
index 43a27d1..a9d1357 100644 (file)
--- a/net/can/isotp.c
+++ b/net/can/isotp.c
@@ -669,7 +669,7 @@ static void isotp_rcv(struct sk_buff *skb, void *data)
                if (cf->len <= CAN_MAX_DLEN) {
                        isotp_rcv_sf(sk, cf, SF_PCI_SZ4 + ae, skb, sf_dl);
                } else {
-                       if (skb->len == CANFD_MTU) {
+                       if (can_is_canfd_skb(skb)) {
                                /* We have a CAN FD frame and CAN_DL is greater than 8:
                                 * Only frames with the SF_DL == 0 ESC value are valid.
                                 *

diff --git a/net/can/j1939/main.c b/net/can/j1939/main.c
index 8452b0f..144c86b 100644 (file)
--- a/net/can/j1939/main.c
+++ b/net/can/j1939/main.c
@@ -42,6 +42,10 @@ static void j1939_can_recv(struct sk_buff *iskb, void *data)
        struct j1939_sk_buff_cb *skcb, *iskcb;
        struct can_frame *cf;
 
+       /* make sure we only get Classical CAN frames */
+       if (!can_is_can_skb(iskb))
+               return;
+
        /* create a copy of the skb
         * j1939 only delivers the real data bytes,
         * the header goes into sockaddr.