1// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) 2/* isotp.c - ISO 15765-2 CAN transport protocol for protocol family CAN 3 * 4 * This implementation does not provide ISO-TP specific return values to the 5 * userspace. 6 * 7 * - RX path timeout of data reception leads to -ETIMEDOUT 8 * - RX path SN mismatch leads to -EILSEQ 9 * - RX path data reception with wrong padding leads to -EBADMSG 10 * - TX path flowcontrol reception timeout leads to -ECOMM 11 * - TX path flowcontrol reception overflow leads to -EMSGSIZE 12 * - TX path flowcontrol reception with wrong layout/padding leads to -EBADMSG 13 * - when a transfer (tx) is on the run the next write() blocks until it's done 14 * - use CAN_ISOTP_WAIT_TX_DONE flag to block the caller until the PDU is sent 15 * - as we have static buffers the check whether the PDU fits into the buffer 16 * is done at FF reception time (no support for sending 'wait frames') 17 * 18 * Copyright (c) 2020 Volkswagen Group Electronic Research 19 * All rights reserved. 20 * 21 * Redistribution and use in source and binary forms, with or without 22 * modification, are permitted provided that the following conditions 23 * are met: 24 * 1. Redistributions of source code must retain the above copyright 25 * notice, this list of conditions and the following disclaimer. 26 * 2. Redistributions in binary form must reproduce the above copyright 27 * notice, this list of conditions and the following disclaimer in the 28 * documentation and/or other materials provided with the distribution. 29 * 3. Neither the name of Volkswagen nor the names of its contributors 30 * may be used to endorse or promote products derived from this software 31 * without specific prior written permission. 32 * 33 * Alternatively, provided that this notice is retained in full, this 34 * software may be distributed under the terms of the GNU General 35 * Public License ("GPL") version 2, in which case the provisions of the 36 * GPL apply INSTEAD OF those given above. 37 * 38 * The provided data structures and external interfaces from this code 39 * are not restricted to be used by modules with a GPL compatible license. 40 * 41 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 42 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 43 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 44 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 45 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 46 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 47 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 48 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 49 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 50 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 51 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH 52 * DAMAGE. 53 */ 54 55#include <linux/module.h> 56#include <linux/init.h> 57#include <linux/interrupt.h> 58#include <linux/spinlock.h> 59#include <linux/hrtimer.h> 60#include <linux/wait.h> 61#include <linux/uio.h> 62#include <linux/net.h> 63#include <linux/netdevice.h> 64#include <linux/socket.h> 65#include <linux/if_arp.h> 66#include <linux/skbuff.h> 67#include <linux/can.h> 68#include <linux/can/core.h> 69#include <linux/can/skb.h> 70#include <linux/can/isotp.h> 71#include <linux/slab.h> 72#include <net/sock.h> 73#include <net/net_namespace.h> 74 75MODULE_DESCRIPTION("PF_CAN isotp 15765-2:2016 protocol"); 76MODULE_LICENSE("Dual BSD/GPL"); 77MODULE_AUTHOR("Oliver Hartkopp <socketcan@hartkopp.net>"); 78MODULE_ALIAS("can-proto-6"); 79 80#define ISOTP_MIN_NAMELEN CAN_REQUIRED_SIZE(struct sockaddr_can, can_addr.tp) 81 82#define SINGLE_MASK(id) (((id) & CAN_EFF_FLAG) ? \ 83 (CAN_EFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG) : \ 84 (CAN_SFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG)) 85 86/* ISO 15765-2:2016 supports more than 4095 byte per ISO PDU as the FF_DL can 87 * take full 32 bit values (4 Gbyte). We would need some good concept to handle 88 * this between user space and kernel space. For now set the static buffer to 89 * something about 8 kbyte to be able to test this new functionality. 90 */ 91#define DEFAULT_MAX_PDU_SIZE 8300 92 93/* maximum PDU size before ISO 15765-2:2016 extension was 4095 */ 94#define MAX_12BIT_PDU_SIZE 4095 95 96/* limit the isotp pdu size from the optional module parameter to 1MByte */ 97#define MAX_PDU_SIZE (1025 * 1024U) 98 99static unsigned int max_pdu_size __read_mostly = DEFAULT_MAX_PDU_SIZE; 100module_param(max_pdu_size, uint, 0444); 101MODULE_PARM_DESC(max_pdu_size, "maximum isotp pdu size (default " 102 __stringify(DEFAULT_MAX_PDU_SIZE) ")"); 103 104/* N_PCI type values in bits 7-4 of N_PCI bytes */ 105#define N_PCI_SF 0x00 /* single frame */ 106#define N_PCI_FF 0x10 /* first frame */ 107#define N_PCI_CF 0x20 /* consecutive frame */ 108#define N_PCI_FC 0x30 /* flow control */ 109 110#define N_PCI_SZ 1 /* size of the PCI byte #1 */ 111#define SF_PCI_SZ4 1 /* size of SingleFrame PCI including 4 bit SF_DL */ 112#define SF_PCI_SZ8 2 /* size of SingleFrame PCI including 8 bit SF_DL */ 113#define FF_PCI_SZ12 2 /* size of FirstFrame PCI including 12 bit FF_DL */ 114#define FF_PCI_SZ32 6 /* size of FirstFrame PCI including 32 bit FF_DL */ 115#define FC_CONTENT_SZ 3 /* flow control content size in byte (FS/BS/STmin) */ 116 117#define ISOTP_CHECK_PADDING (CAN_ISOTP_CHK_PAD_LEN | CAN_ISOTP_CHK_PAD_DATA) 118#define ISOTP_ALL_BC_FLAGS (CAN_ISOTP_SF_BROADCAST | CAN_ISOTP_CF_BROADCAST) 119 120/* Flow Status given in FC frame */ 121#define ISOTP_FC_CTS 0 /* clear to send */ 122#define ISOTP_FC_WT 1 /* wait */ 123#define ISOTP_FC_OVFLW 2 /* overflow */ 124 125#define ISOTP_FC_TIMEOUT 1 /* 1 sec */ 126#define ISOTP_ECHO_TIMEOUT 2 /* 2 secs */ 127 128enum { 129 ISOTP_IDLE = 0, 130 ISOTP_WAIT_FIRST_FC, 131 ISOTP_WAIT_FC, 132 ISOTP_WAIT_DATA, 133 ISOTP_SENDING, 134 ISOTP_SHUTDOWN, 135}; 136 137struct tpcon { 138 u8 *buf; 139 unsigned int buflen; 140 unsigned int len; 141 unsigned int idx; 142 u32 state; 143 u8 bs; 144 u8 sn; 145 u8 ll_dl; 146 u8 sbuf[DEFAULT_MAX_PDU_SIZE]; 147}; 148 149struct isotp_sock { 150 struct sock sk; 151 int bound; 152 int ifindex; 153 canid_t txid; 154 canid_t rxid; 155 ktime_t tx_gap; 156 ktime_t lastrxcf_tstamp; 157 struct hrtimer rxtimer, txtimer, txfrtimer; 158 struct can_isotp_options opt; 159 struct can_isotp_fc_options rxfc, txfc; 160 struct can_isotp_ll_options ll; 161 u32 frame_txtime; 162 u32 force_tx_stmin; 163 u32 force_rx_stmin; 164 u32 cfecho; /* consecutive frame echo tag */ 165 struct tpcon rx, tx; 166 struct list_head notifier; 167 wait_queue_head_t wait; 168 spinlock_t rx_lock; /* protect single thread state machine */ 169}; 170 171static LIST_HEAD(isotp_notifier_list); 172static DEFINE_SPINLOCK(isotp_notifier_lock); 173static struct isotp_sock *isotp_busy_notifier; 174 175static inline struct isotp_sock *isotp_sk(const struct sock *sk) 176{ 177 return (struct isotp_sock *)sk; 178} 179 180static u32 isotp_bc_flags(struct isotp_sock *so) 181{ 182 return so->opt.flags & ISOTP_ALL_BC_FLAGS; 183} 184 185static bool isotp_register_rxid(struct isotp_sock *so) 186{ 187 /* no broadcast modes => register rx_id for FC frame reception */ 188 return (isotp_bc_flags(so) == 0); 189} 190 191static enum hrtimer_restart isotp_rx_timer_handler(struct hrtimer *hrtimer) 192{ 193 struct isotp_sock *so = container_of(hrtimer, struct isotp_sock, 194 rxtimer); 195 struct sock *sk = &so->sk; 196 197 if (so->rx.state == ISOTP_WAIT_DATA) { 198 /* we did not get new data frames in time */ 199 200 /* report 'connection timed out' */ 201 sk->sk_err = ETIMEDOUT; 202 if (!sock_flag(sk, SOCK_DEAD)) 203 sk_error_report(sk); 204 205 /* reset rx state */ 206 so->rx.state = ISOTP_IDLE; 207 } 208 209 return HRTIMER_NORESTART; 210} 211 212static int isotp_send_fc(struct sock *sk, int ae, u8 flowstatus) 213{ 214 struct net_device *dev; 215 struct sk_buff *nskb; 216 struct canfd_frame *ncf; 217 struct isotp_sock *so = isotp_sk(sk); 218 int can_send_ret; 219 220 nskb = alloc_skb(so->ll.mtu + sizeof(struct can_skb_priv), gfp_any()); 221 if (!nskb) 222 return 1; 223 224 dev = dev_get_by_index(sock_net(sk), so->ifindex); 225 if (!dev) { 226 kfree_skb(nskb); 227 return 1; 228 } 229 230 can_skb_reserve(nskb); 231 can_skb_prv(nskb)->ifindex = dev->ifindex; 232 can_skb_prv(nskb)->skbcnt = 0; 233 234 nskb->dev = dev; 235 can_skb_set_owner(nskb, sk); 236 ncf = (struct canfd_frame *)nskb->data; 237 skb_put_zero(nskb, so->ll.mtu); 238 239 /* create & send flow control reply */ 240 ncf->can_id = so->txid; 241 242 if (so->opt.flags & CAN_ISOTP_TX_PADDING) { 243 memset(ncf->data, so->opt.txpad_content, CAN_MAX_DLEN); 244 ncf->len = CAN_MAX_DLEN; 245 } else { 246 ncf->len = ae + FC_CONTENT_SZ; 247 } 248 249 ncf->data[ae] = N_PCI_FC | flowstatus; 250 ncf->data[ae + 1] = so->rxfc.bs; 251 ncf->data[ae + 2] = so->rxfc.stmin; 252 253 if (ae) 254 ncf->data[0] = so->opt.ext_address; 255 256 ncf->flags = so->ll.tx_flags; 257 258 can_send_ret = can_send(nskb, 1); 259 if (can_send_ret) 260 pr_notice_once("can-isotp: %s: can_send_ret %pe\n", 261 __func__, ERR_PTR(can_send_ret)); 262 263 dev_put(dev); 264 265 /* reset blocksize counter */ 266 so->rx.bs = 0; 267 268 /* reset last CF frame rx timestamp for rx stmin enforcement */ 269 so->lastrxcf_tstamp = ktime_set(0, 0); 270 271 /* start rx timeout watchdog */ 272 hrtimer_start(&so->rxtimer, ktime_set(ISOTP_FC_TIMEOUT, 0), 273 HRTIMER_MODE_REL_SOFT); 274 return 0; 275} 276 277static void isotp_rcv_skb(struct sk_buff *skb, struct sock *sk) 278{ 279 struct sockaddr_can *addr = (struct sockaddr_can *)skb->cb; 280 281 BUILD_BUG_ON(sizeof(skb->cb) < sizeof(struct sockaddr_can)); 282 283 memset(addr, 0, sizeof(*addr)); 284 addr->can_family = AF_CAN; 285 addr->can_ifindex = skb->dev->ifindex; 286 287 if (sock_queue_rcv_skb(sk, skb) < 0) 288 kfree_skb(skb); 289} 290 291static u8 padlen(u8 datalen) 292{ 293 static const u8 plen[] = { 294 8, 8, 8, 8, 8, 8, 8, 8, 8, /* 0 - 8 */ 295 12, 12, 12, 12, /* 9 - 12 */ 296 16, 16, 16, 16, /* 13 - 16 */ 297 20, 20, 20, 20, /* 17 - 20 */ 298 24, 24, 24, 24, /* 21 - 24 */ 299 32, 32, 32, 32, 32, 32, 32, 32, /* 25 - 32 */ 300 48, 48, 48, 48, 48, 48, 48, 48, /* 33 - 40 */ 301 48, 48, 48, 48, 48, 48, 48, 48 /* 41 - 48 */ 302 }; 303 304 if (datalen > 48) 305 return 64; 306 307 return plen[datalen]; 308} 309 310/* check for length optimization and return 1/true when the check fails */ 311static int check_optimized(struct canfd_frame *cf, int start_index) 312{ 313 /* for CAN_DL <= 8 the start_index is equal to the CAN_DL as the 314 * padding would start at this point. E.g. if the padding would 315 * start at cf.data[7] cf->len has to be 7 to be optimal. 316 * Note: The data[] index starts with zero. 317 */ 318 if (cf->len <= CAN_MAX_DLEN) 319 return (cf->len != start_index); 320 321 /* This relation is also valid in the non-linear DLC range, where 322 * we need to take care of the minimal next possible CAN_DL. 323 * The correct check would be (padlen(cf->len) != padlen(start_index)). 324 * But as cf->len can only take discrete values from 12, .., 64 at this 325 * point the padlen(cf->len) is always equal to cf->len. 326 */ 327 return (cf->len != padlen(start_index)); 328} 329 330/* check padding and return 1/true when the check fails */ 331static int check_pad(struct isotp_sock *so, struct canfd_frame *cf, 332 int start_index, u8 content) 333{ 334 int i; 335 336 /* no RX_PADDING value => check length of optimized frame length */ 337 if (!(so->opt.flags & CAN_ISOTP_RX_PADDING)) { 338 if (so->opt.flags & CAN_ISOTP_CHK_PAD_LEN) 339 return check_optimized(cf, start_index); 340 341 /* no valid test against empty value => ignore frame */ 342 return 1; 343 } 344 345 /* check datalength of correctly padded CAN frame */ 346 if ((so->opt.flags & CAN_ISOTP_CHK_PAD_LEN) && 347 cf->len != padlen(cf->len)) 348 return 1; 349 350 /* check padding content */ 351 if (so->opt.flags & CAN_ISOTP_CHK_PAD_DATA) { 352 for (i = start_index; i < cf->len; i++) 353 if (cf->data[i] != content) 354 return 1; 355 } 356 return 0; 357} 358 359static void isotp_send_cframe(struct isotp_sock *so); 360 361static int isotp_rcv_fc(struct isotp_sock *so, struct canfd_frame *cf, int ae) 362{ 363 struct sock *sk = &so->sk; 364 365 if (so->tx.state != ISOTP_WAIT_FC && 366 so->tx.state != ISOTP_WAIT_FIRST_FC) 367 return 0; 368 369 hrtimer_cancel(&so->txtimer); 370 371 if ((cf->len < ae + FC_CONTENT_SZ) || 372 ((so->opt.flags & ISOTP_CHECK_PADDING) && 373 check_pad(so, cf, ae + FC_CONTENT_SZ, so->opt.rxpad_content))) { 374 /* malformed PDU - report 'not a data message' */ 375 sk->sk_err = EBADMSG; 376 if (!sock_flag(sk, SOCK_DEAD)) 377 sk_error_report(sk); 378 379 so->tx.state = ISOTP_IDLE; 380 wake_up_interruptible(&so->wait); 381 return 1; 382 } 383 384 /* get static/dynamic communication params from first/every FC frame */ 385 if (so->tx.state == ISOTP_WAIT_FIRST_FC || 386 so->opt.flags & CAN_ISOTP_DYN_FC_PARMS) { 387 so->txfc.bs = cf->data[ae + 1]; 388 so->txfc.stmin = cf->data[ae + 2]; 389 390 /* fix wrong STmin values according spec */ 391 if (so->txfc.stmin > 0x7F && 392 (so->txfc.stmin < 0xF1 || so->txfc.stmin > 0xF9)) 393 so->txfc.stmin = 0x7F; 394 395 so->tx_gap = ktime_set(0, 0); 396 /* add transmission time for CAN frame N_As */ 397 so->tx_gap = ktime_add_ns(so->tx_gap, so->frame_txtime); 398 /* add waiting time for consecutive frames N_Cs */ 399 if (so->opt.flags & CAN_ISOTP_FORCE_TXSTMIN) 400 so->tx_gap = ktime_add_ns(so->tx_gap, 401 so->force_tx_stmin); 402 else if (so->txfc.stmin < 0x80) 403 so->tx_gap = ktime_add_ns(so->tx_gap, 404 so->txfc.stmin * 1000000); 405 else 406 so->tx_gap = ktime_add_ns(so->tx_gap, 407 (so->txfc.stmin - 0xF0) 408 * 100000); 409 so->tx.state = ISOTP_WAIT_FC; 410 } 411 412 switch (cf->data[ae] & 0x0F) { 413 case ISOTP_FC_CTS: 414 so->tx.bs = 0; 415 so->tx.state = ISOTP_SENDING; 416 /* send CF frame and enable echo timeout handling */ 417 hrtimer_start(&so->txtimer, ktime_set(ISOTP_ECHO_TIMEOUT, 0), 418 HRTIMER_MODE_REL_SOFT); 419 isotp_send_cframe(so); 420 break; 421 422 case ISOTP_FC_WT: 423 /* start timer to wait for next FC frame */ 424 hrtimer_start(&so->txtimer, ktime_set(ISOTP_FC_TIMEOUT, 0), 425 HRTIMER_MODE_REL_SOFT); 426 break; 427 428 case ISOTP_FC_OVFLW: 429 /* overflow on receiver side - report 'message too long' */ 430 sk->sk_err = EMSGSIZE; 431 if (!sock_flag(sk, SOCK_DEAD)) 432 sk_error_report(sk); 433 fallthrough; 434 435 default: 436 /* stop this tx job */ 437 so->tx.state = ISOTP_IDLE; 438 wake_up_interruptible(&so->wait); 439 } 440 return 0; 441} 442 443static int isotp_rcv_sf(struct sock *sk, struct canfd_frame *cf, int pcilen, 444 struct sk_buff *skb, int len) 445{ 446 struct isotp_sock *so = isotp_sk(sk); 447 struct sk_buff *nskb; 448 449 hrtimer_cancel(&so->rxtimer); 450 so->rx.state = ISOTP_IDLE; 451 452 if (!len || len > cf->len - pcilen) 453 return 1; 454 455 if ((so->opt.flags & ISOTP_CHECK_PADDING) && 456 check_pad(so, cf, pcilen + len, so->opt.rxpad_content)) { 457 /* malformed PDU - report 'not a data message' */ 458 sk->sk_err = EBADMSG; 459 if (!sock_flag(sk, SOCK_DEAD)) 460 sk_error_report(sk); 461 return 1; 462 } 463 464 nskb = alloc_skb(len, gfp_any()); 465 if (!nskb) 466 return 1; 467 468 memcpy(skb_put(nskb, len), &cf->data[pcilen], len); 469 470 nskb->tstamp = skb->tstamp; 471 nskb->dev = skb->dev; 472 isotp_rcv_skb(nskb, sk); 473 return 0; 474} 475 476static int isotp_rcv_ff(struct sock *sk, struct canfd_frame *cf, int ae) 477{ 478 struct isotp_sock *so = isotp_sk(sk); 479 int i; 480 int off; 481 int ff_pci_sz; 482 483 hrtimer_cancel(&so->rxtimer); 484 so->rx.state = ISOTP_IDLE; 485 486 /* get the used sender LL_DL from the (first) CAN frame data length */ 487 so->rx.ll_dl = padlen(cf->len); 488 489 /* the first frame has to use the entire frame up to LL_DL length */ 490 if (cf->len != so->rx.ll_dl) 491 return 1; 492 493 /* get the FF_DL */ 494 so->rx.len = (cf->data[ae] & 0x0F) << 8; 495 so->rx.len += cf->data[ae + 1]; 496 497 /* Check for FF_DL escape sequence supporting 32 bit PDU length */ 498 if (so->rx.len) { 499 ff_pci_sz = FF_PCI_SZ12; 500 } else { 501 /* FF_DL = 0 => get real length from next 4 bytes */ 502 so->rx.len = cf->data[ae + 2] << 24; 503 so->rx.len += cf->data[ae + 3] << 16; 504 so->rx.len += cf->data[ae + 4] << 8; 505 so->rx.len += cf->data[ae + 5]; 506 ff_pci_sz = FF_PCI_SZ32; 507 } 508 509 /* take care of a potential SF_DL ESC offset for TX_DL > 8 */ 510 off = (so->rx.ll_dl > CAN_MAX_DLEN) ? 1 : 0; 511 512 if (so->rx.len + ae + off + ff_pci_sz < so->rx.ll_dl) 513 return 1; 514 515 /* PDU size > default => try max_pdu_size */ 516 if (so->rx.len > so->rx.buflen && so->rx.buflen < max_pdu_size) { 517 u8 *newbuf = kmalloc(max_pdu_size, GFP_ATOMIC); 518 519 if (newbuf) { 520 so->rx.buf = newbuf; 521 so->rx.buflen = max_pdu_size; 522 } 523 } 524 525 if (so->rx.len > so->rx.buflen) { 526 /* send FC frame with overflow status */ 527 isotp_send_fc(sk, ae, ISOTP_FC_OVFLW); 528 return 1; 529 } 530 531 /* copy the first received data bytes */ 532 so->rx.idx = 0; 533 for (i = ae + ff_pci_sz; i < so->rx.ll_dl; i++) 534 so->rx.buf[so->rx.idx++] = cf->data[i]; 535 536 /* initial setup for this pdu reception */ 537 so->rx.sn = 1; 538 so->rx.state = ISOTP_WAIT_DATA; 539 540 /* no creation of flow control frames */ 541 if (so->opt.flags & CAN_ISOTP_LISTEN_MODE) 542 return 0; 543 544 /* send our first FC frame */ 545 isotp_send_fc(sk, ae, ISOTP_FC_CTS); 546 return 0; 547} 548 549static int isotp_rcv_cf(struct sock *sk, struct canfd_frame *cf, int ae, 550 struct sk_buff *skb) 551{ 552 struct isotp_sock *so = isotp_sk(sk); 553 struct sk_buff *nskb; 554 int i; 555 556 if (so->rx.state != ISOTP_WAIT_DATA) 557 return 0; 558 559 /* drop if timestamp gap is less than force_rx_stmin nano secs */ 560 if (so->opt.flags & CAN_ISOTP_FORCE_RXSTMIN) { 561 if (ktime_to_ns(ktime_sub(skb->tstamp, so->lastrxcf_tstamp)) < 562 so->force_rx_stmin) 563 return 0; 564 565 so->lastrxcf_tstamp = skb->tstamp; 566 } 567 568 hrtimer_cancel(&so->rxtimer); 569 570 /* CFs are never longer than the FF */ 571 if (cf->len > so->rx.ll_dl) 572 return 1; 573 574 /* CFs have usually the LL_DL length */ 575 if (cf->len < so->rx.ll_dl) { 576 /* this is only allowed for the last CF */ 577 if (so->rx.len - so->rx.idx > so->rx.ll_dl - ae - N_PCI_SZ) 578 return 1; 579 } 580 581 if ((cf->data[ae] & 0x0F) != so->rx.sn) { 582 /* wrong sn detected - report 'illegal byte sequence' */ 583 sk->sk_err = EILSEQ; 584 if (!sock_flag(sk, SOCK_DEAD)) 585 sk_error_report(sk); 586 587 /* reset rx state */ 588 so->rx.state = ISOTP_IDLE; 589 return 1; 590 } 591 so->rx.sn++; 592 so->rx.sn %= 16; 593 594 for (i = ae + N_PCI_SZ; i < cf->len; i++) { 595 so->rx.buf[so->rx.idx++] = cf->data[i]; 596 if (so->rx.idx >= so->rx.len) 597 break; 598 } 599 600 if (so->rx.idx >= so->rx.len) { 601 /* we are done */ 602 so->rx.state = ISOTP_IDLE; 603 604 if ((so->opt.flags & ISOTP_CHECK_PADDING) && 605 check_pad(so, cf, i + 1, so->opt.rxpad_content)) { 606 /* malformed PDU - report 'not a data message' */ 607 sk->sk_err = EBADMSG; 608 if (!sock_flag(sk, SOCK_DEAD)) 609 sk_error_report(sk); 610 return 1; 611 } 612 613 nskb = alloc_skb(so->rx.len, gfp_any()); 614 if (!nskb) 615 return 1; 616 617 memcpy(skb_put(nskb, so->rx.len), so->rx.buf, 618 so->rx.len); 619 620 nskb->tstamp = skb->tstamp; 621 nskb->dev = skb->dev; 622 isotp_rcv_skb(nskb, sk); 623 return 0; 624 } 625 626 /* perform blocksize handling, if enabled */ 627 if (!so->rxfc.bs || ++so->rx.bs < so->rxfc.bs) { 628 /* start rx timeout watchdog */ 629 hrtimer_start(&so->rxtimer, ktime_set(ISOTP_FC_TIMEOUT, 0), 630 HRTIMER_MODE_REL_SOFT); 631 return 0; 632 } 633 634 /* no creation of flow control frames */ 635 if (so->opt.flags & CAN_ISOTP_LISTEN_MODE) 636 return 0; 637 638 /* we reached the specified blocksize so->rxfc.bs */ 639 isotp_send_fc(sk, ae, ISOTP_FC_CTS); 640 return 0; 641} 642 643static void isotp_rcv(struct sk_buff *skb, void *data) 644{ 645 struct sock *sk = (struct sock *)data; 646 struct isotp_sock *so = isotp_sk(sk); 647 struct canfd_frame *cf; 648 int ae = (so->opt.flags & CAN_ISOTP_EXTEND_ADDR) ? 1 : 0; 649 u8 n_pci_type, sf_dl; 650 651 /* Strictly receive only frames with the configured MTU size 652 * => clear separation of CAN2.0 / CAN FD transport channels 653 */ 654 if (skb->len != so->ll.mtu) 655 return; 656 657 cf = (struct canfd_frame *)skb->data; 658 659 /* if enabled: check reception of my configured extended address */ 660 if (ae && cf->data[0] != so->opt.rx_ext_address) 661 return; 662 663 n_pci_type = cf->data[ae] & 0xF0; 664 665 /* Make sure the state changes and data structures stay consistent at 666 * CAN frame reception time. This locking is not needed in real world 667 * use cases but the inconsistency can be triggered with syzkaller. 668 */ 669 spin_lock(&so->rx_lock); 670 671 if (so->opt.flags & CAN_ISOTP_HALF_DUPLEX) { 672 /* check rx/tx path half duplex expectations */ 673 if ((so->tx.state != ISOTP_IDLE && n_pci_type != N_PCI_FC) || 674 (so->rx.state != ISOTP_IDLE && n_pci_type == N_PCI_FC)) 675 goto out_unlock; 676 } 677 678 switch (n_pci_type) { 679 case N_PCI_FC: 680 /* tx path: flow control frame containing the FC parameters */ 681 isotp_rcv_fc(so, cf, ae); 682 break; 683 684 case N_PCI_SF: 685 /* rx path: single frame 686 * 687 * As we do not have a rx.ll_dl configuration, we can only test 688 * if the CAN frames payload length matches the LL_DL == 8 689 * requirements - no matter if it's CAN 2.0 or CAN FD 690 */ 691 692 /* get the SF_DL from the N_PCI byte */ 693 sf_dl = cf->data[ae] & 0x0F; 694 695 if (cf->len <= CAN_MAX_DLEN) { 696 isotp_rcv_sf(sk, cf, SF_PCI_SZ4 + ae, skb, sf_dl); 697 } else { 698 if (can_is_canfd_skb(skb)) { 699 /* We have a CAN FD frame and CAN_DL is greater than 8: 700 * Only frames with the SF_DL == 0 ESC value are valid. 701 * 702 * If so take care of the increased SF PCI size 703 * (SF_PCI_SZ8) to point to the message content behind 704 * the extended SF PCI info and get the real SF_DL 705 * length value from the formerly first data byte. 706 */ 707 if (sf_dl == 0) 708 isotp_rcv_sf(sk, cf, SF_PCI_SZ8 + ae, skb, 709 cf->data[SF_PCI_SZ4 + ae]); 710 } 711 } 712 break; 713 714 case N_PCI_FF: 715 /* rx path: first frame */ 716 isotp_rcv_ff(sk, cf, ae); 717 break; 718 719 case N_PCI_CF: 720 /* rx path: consecutive frame */ 721 isotp_rcv_cf(sk, cf, ae, skb); 722 break; 723 } 724 725out_unlock: 726 spin_unlock(&so->rx_lock); 727} 728 729static void isotp_fill_dataframe(struct canfd_frame *cf, struct isotp_sock *so, 730 int ae, int off) 731{ 732 int pcilen = N_PCI_SZ + ae + off; 733 int space = so->tx.ll_dl - pcilen; 734 int num = min_t(int, so->tx.len - so->tx.idx, space); 735 int i; 736 737 cf->can_id = so->txid; 738 cf->len = num + pcilen; 739 740 if (num < space) { 741 if (so->opt.flags & CAN_ISOTP_TX_PADDING) { 742 /* user requested padding */ 743 cf->len = padlen(cf->len); 744 memset(cf->data, so->opt.txpad_content, cf->len); 745 } else if (cf->len > CAN_MAX_DLEN) { 746 /* mandatory padding for CAN FD frames */ 747 cf->len = padlen(cf->len); 748 memset(cf->data, CAN_ISOTP_DEFAULT_PAD_CONTENT, 749 cf->len); 750 } 751 } 752 753 for (i = 0; i < num; i++) 754 cf->data[pcilen + i] = so->tx.buf[so->tx.idx++]; 755 756 if (ae) 757 cf->data[0] = so->opt.ext_address; 758} 759 760static void isotp_send_cframe(struct isotp_sock *so) 761{ 762 struct sock *sk = &so->sk; 763 struct sk_buff *skb; 764 struct net_device *dev; 765 struct canfd_frame *cf; 766 int can_send_ret; 767 int ae = (so->opt.flags & CAN_ISOTP_EXTEND_ADDR) ? 1 : 0; 768 769 dev = dev_get_by_index(sock_net(sk), so->ifindex); 770 if (!dev) 771 return; 772 773 skb = alloc_skb(so->ll.mtu + sizeof(struct can_skb_priv), GFP_ATOMIC); 774 if (!skb) { 775 dev_put(dev); 776 return; 777 } 778 779 can_skb_reserve(skb); 780 can_skb_prv(skb)->ifindex = dev->ifindex; 781 can_skb_prv(skb)->skbcnt = 0; 782 783 cf = (struct canfd_frame *)skb->data; 784 skb_put_zero(skb, so->ll.mtu); 785 786 /* create consecutive frame */ 787 isotp_fill_dataframe(cf, so, ae, 0); 788 789 /* place consecutive frame N_PCI in appropriate index */ 790 cf->data[ae] = N_PCI_CF | so->tx.sn++; 791 so->tx.sn %= 16; 792 so->tx.bs++; 793 794 cf->flags = so->ll.tx_flags; 795 796 skb->dev = dev; 797 can_skb_set_owner(skb, sk); 798 799 /* cfecho should have been zero'ed by init/isotp_rcv_echo() */ 800 if (so->cfecho) 801 pr_notice_once("can-isotp: cfecho is %08X != 0\n", so->cfecho); 802 803 /* set consecutive frame echo tag */ 804 so->cfecho = *(u32 *)cf->data; 805 806 /* send frame with local echo enabled */ 807 can_send_ret = can_send(skb, 1); 808 if (can_send_ret) { 809 pr_notice_once("can-isotp: %s: can_send_ret %pe\n", 810 __func__, ERR_PTR(can_send_ret)); 811 if (can_send_ret == -ENOBUFS) 812 pr_notice_once("can-isotp: tx queue is full\n"); 813 } 814 dev_put(dev); 815} 816 817static void isotp_create_fframe(struct canfd_frame *cf, struct isotp_sock *so, 818 int ae) 819{ 820 int i; 821 int ff_pci_sz; 822 823 cf->can_id = so->txid; 824 cf->len = so->tx.ll_dl; 825 if (ae) 826 cf->data[0] = so->opt.ext_address; 827 828 /* create N_PCI bytes with 12/32 bit FF_DL data length */ 829 if (so->tx.len > MAX_12BIT_PDU_SIZE) { 830 /* use 32 bit FF_DL notation */ 831 cf->data[ae] = N_PCI_FF; 832 cf->data[ae + 1] = 0; 833 cf->data[ae + 2] = (u8)(so->tx.len >> 24) & 0xFFU; 834 cf->data[ae + 3] = (u8)(so->tx.len >> 16) & 0xFFU; 835 cf->data[ae + 4] = (u8)(so->tx.len >> 8) & 0xFFU; 836 cf->data[ae + 5] = (u8)so->tx.len & 0xFFU; 837 ff_pci_sz = FF_PCI_SZ32; 838 } else { 839 /* use 12 bit FF_DL notation */ 840 cf->data[ae] = (u8)(so->tx.len >> 8) | N_PCI_FF; 841 cf->data[ae + 1] = (u8)so->tx.len & 0xFFU; 842 ff_pci_sz = FF_PCI_SZ12; 843 } 844 845 /* add first data bytes depending on ae */ 846 for (i = ae + ff_pci_sz; i < so->tx.ll_dl; i++) 847 cf->data[i] = so->tx.buf[so->tx.idx++]; 848 849 so->tx.sn = 1; 850} 851 852static void isotp_rcv_echo(struct sk_buff *skb, void *data) 853{ 854 struct sock *sk = (struct sock *)data; 855 struct isotp_sock *so = isotp_sk(sk); 856 struct canfd_frame *cf = (struct canfd_frame *)skb->data; 857 858 /* only handle my own local echo CF/SF skb's (no FF!) */ 859 if (skb->sk != sk || so->cfecho != *(u32 *)cf->data) 860 return; 861 862 /* cancel local echo timeout */ 863 hrtimer_cancel(&so->txtimer); 864 865 /* local echo skb with consecutive frame has been consumed */ 866 so->cfecho = 0; 867 868 if (so->tx.idx >= so->tx.len) { 869 /* we are done */ 870 so->tx.state = ISOTP_IDLE; 871 wake_up_interruptible(&so->wait); 872 return; 873 } 874 875 if (so->txfc.bs && so->tx.bs >= so->txfc.bs) { 876 /* stop and wait for FC with timeout */ 877 so->tx.state = ISOTP_WAIT_FC; 878 hrtimer_start(&so->txtimer, ktime_set(ISOTP_FC_TIMEOUT, 0), 879 HRTIMER_MODE_REL_SOFT); 880 return; 881 } 882 883 /* no gap between data frames needed => use burst mode */ 884 if (!so->tx_gap) { 885 /* enable echo timeout handling */ 886 hrtimer_start(&so->txtimer, ktime_set(ISOTP_ECHO_TIMEOUT, 0), 887 HRTIMER_MODE_REL_SOFT); 888 isotp_send_cframe(so); 889 return; 890 } 891 892 /* start timer to send next consecutive frame with correct delay */ 893 hrtimer_start(&so->txfrtimer, so->tx_gap, HRTIMER_MODE_REL_SOFT); 894} 895 896static enum hrtimer_restart isotp_tx_timer_handler(struct hrtimer *hrtimer) 897{ 898 struct isotp_sock *so = container_of(hrtimer, struct isotp_sock, 899 txtimer); 900 struct sock *sk = &so->sk; 901 902 /* don't handle timeouts in IDLE or SHUTDOWN state */ 903 if (so->tx.state == ISOTP_IDLE || so->tx.state == ISOTP_SHUTDOWN) 904 return HRTIMER_NORESTART; 905 906 /* we did not get any flow control or echo frame in time */ 907 908 /* report 'communication error on send' */ 909 sk->sk_err = ECOMM; 910 if (!sock_flag(sk, SOCK_DEAD)) 911 sk_error_report(sk); 912 913 /* reset tx state */ 914 so->tx.state = ISOTP_IDLE; 915 wake_up_interruptible(&so->wait); 916 917 return HRTIMER_NORESTART; 918} 919 920static enum hrtimer_restart isotp_txfr_timer_handler(struct hrtimer *hrtimer) 921{ 922 struct isotp_sock *so = container_of(hrtimer, struct isotp_sock, 923 txfrtimer); 924 925 /* start echo timeout handling and cover below protocol error */ 926 hrtimer_start(&so->txtimer, ktime_set(ISOTP_ECHO_TIMEOUT, 0), 927 HRTIMER_MODE_REL_SOFT); 928 929 /* cfecho should be consumed by isotp_rcv_echo() here */ 930 if (so->tx.state == ISOTP_SENDING && !so->cfecho) 931 isotp_send_cframe(so); 932 933 return HRTIMER_NORESTART; 934} 935 936static int isotp_sendmsg(struct socket *sock, struct msghdr *msg, size_t size) 937{ 938 struct sock *sk = sock->sk; 939 struct isotp_sock *so = isotp_sk(sk); 940 struct sk_buff *skb; 941 struct net_device *dev; 942 struct canfd_frame *cf; 943 int ae = (so->opt.flags & CAN_ISOTP_EXTEND_ADDR) ? 1 : 0; 944 int wait_tx_done = (so->opt.flags & CAN_ISOTP_WAIT_TX_DONE) ? 1 : 0; 945 s64 hrtimer_sec = ISOTP_ECHO_TIMEOUT; 946 int off; 947 int err; 948 949 if (!so->bound || so->tx.state == ISOTP_SHUTDOWN) 950 return -EADDRNOTAVAIL; 951 952 while (cmpxchg(&so->tx.state, ISOTP_IDLE, ISOTP_SENDING) != ISOTP_IDLE) { 953 /* we do not support multiple buffers - for now */ 954 if (msg->msg_flags & MSG_DONTWAIT) 955 return -EAGAIN; 956 957 if (so->tx.state == ISOTP_SHUTDOWN) 958 return -EADDRNOTAVAIL; 959 960 /* wait for complete transmission of current pdu */ 961 err = wait_event_interruptible(so->wait, so->tx.state == ISOTP_IDLE); 962 if (err) 963 goto err_event_drop; 964 } 965 966 /* PDU size > default => try max_pdu_size */ 967 if (size > so->tx.buflen && so->tx.buflen < max_pdu_size) { 968 u8 *newbuf = kmalloc(max_pdu_size, GFP_KERNEL); 969 970 if (newbuf) { 971 so->tx.buf = newbuf; 972 so->tx.buflen = max_pdu_size; 973 } 974 } 975 976 if (!size || size > so->tx.buflen) { 977 err = -EINVAL; 978 goto err_out_drop; 979 } 980 981 /* take care of a potential SF_DL ESC offset for TX_DL > 8 */ 982 off = (so->tx.ll_dl > CAN_MAX_DLEN) ? 1 : 0; 983 984 /* does the given data fit into a single frame for SF_BROADCAST? */ 985 if ((isotp_bc_flags(so) == CAN_ISOTP_SF_BROADCAST) && 986 (size > so->tx.ll_dl - SF_PCI_SZ4 - ae - off)) { 987 err = -EINVAL; 988 goto err_out_drop; 989 } 990 991 err = memcpy_from_msg(so->tx.buf, msg, size); 992 if (err < 0) 993 goto err_out_drop; 994 995 dev = dev_get_by_index(sock_net(sk), so->ifindex); 996 if (!dev) { 997 err = -ENXIO; 998 goto err_out_drop; 999 } 1000 1001 skb = sock_alloc_send_skb(sk, so->ll.mtu + sizeof(struct can_skb_priv), 1002 msg->msg_flags & MSG_DONTWAIT, &err); 1003 if (!skb) { 1004 dev_put(dev); 1005 goto err_out_drop; 1006 } 1007 1008 can_skb_reserve(skb); 1009 can_skb_prv(skb)->ifindex = dev->ifindex; 1010 can_skb_prv(skb)->skbcnt = 0; 1011 1012 so->tx.len = size; 1013 so->tx.idx = 0; 1014 1015 cf = (struct canfd_frame *)skb->data; 1016 skb_put_zero(skb, so->ll.mtu); 1017 1018 /* cfecho should have been zero'ed by init / former isotp_rcv_echo() */ 1019 if (so->cfecho) 1020 pr_notice_once("can-isotp: uninit cfecho %08X\n", so->cfecho); 1021 1022 /* check for single frame transmission depending on TX_DL */ 1023 if (size <= so->tx.ll_dl - SF_PCI_SZ4 - ae - off) { 1024 /* The message size generally fits into a SingleFrame - good. 1025 * 1026 * SF_DL ESC offset optimization: 1027 * 1028 * When TX_DL is greater 8 but the message would still fit 1029 * into a 8 byte CAN frame, we can omit the offset. 1030 * This prevents a protocol caused length extension from 1031 * CAN_DL = 8 to CAN_DL = 12 due to the SF_SL ESC handling. 1032 */ 1033 if (size <= CAN_MAX_DLEN - SF_PCI_SZ4 - ae) 1034 off = 0; 1035 1036 isotp_fill_dataframe(cf, so, ae, off); 1037 1038 /* place single frame N_PCI w/o length in appropriate index */ 1039 cf->data[ae] = N_PCI_SF; 1040 1041 /* place SF_DL size value depending on the SF_DL ESC offset */ 1042 if (off) 1043 cf->data[SF_PCI_SZ4 + ae] = size; 1044 else 1045 cf->data[ae] |= size; 1046 1047 /* set CF echo tag for isotp_rcv_echo() (SF-mode) */ 1048 so->cfecho = *(u32 *)cf->data; 1049 } else { 1050 /* send first frame */ 1051 1052 isotp_create_fframe(cf, so, ae); 1053 1054 if (isotp_bc_flags(so) == CAN_ISOTP_CF_BROADCAST) { 1055 /* set timer for FC-less operation (STmin = 0) */ 1056 if (so->opt.flags & CAN_ISOTP_FORCE_TXSTMIN) 1057 so->tx_gap = ktime_set(0, so->force_tx_stmin); 1058 else 1059 so->tx_gap = ktime_set(0, so->frame_txtime); 1060 1061 /* disable wait for FCs due to activated block size */ 1062 so->txfc.bs = 0; 1063 1064 /* set CF echo tag for isotp_rcv_echo() (CF-mode) */ 1065 so->cfecho = *(u32 *)cf->data; 1066 } else { 1067 /* standard flow control check */ 1068 so->tx.state = ISOTP_WAIT_FIRST_FC; 1069 1070 /* start timeout for FC */ 1071 hrtimer_sec = ISOTP_FC_TIMEOUT; 1072 1073 /* no CF echo tag for isotp_rcv_echo() (FF-mode) */ 1074 so->cfecho = 0; 1075 } 1076 } 1077 1078 hrtimer_start(&so->txtimer, ktime_set(hrtimer_sec, 0), 1079 HRTIMER_MODE_REL_SOFT); 1080 1081 /* send the first or only CAN frame */ 1082 cf->flags = so->ll.tx_flags; 1083 1084 skb->dev = dev; 1085 skb->sk = sk; 1086 err = can_send(skb, 1); 1087 dev_put(dev); 1088 if (err) { 1089 pr_notice_once("can-isotp: %s: can_send_ret %pe\n", 1090 __func__, ERR_PTR(err)); 1091 1092 /* no transmission -> no timeout monitoring */ 1093 hrtimer_cancel(&so->txtimer); 1094 1095 /* reset consecutive frame echo tag */ 1096 so->cfecho = 0; 1097 1098 goto err_out_drop; 1099 } 1100 1101 if (wait_tx_done) { 1102 /* wait for complete transmission of current pdu */ 1103 err = wait_event_interruptible(so->wait, so->tx.state == ISOTP_IDLE); 1104 if (err) 1105 goto err_event_drop; 1106 1107 err = sock_error(sk); 1108 if (err) 1109 return err; 1110 } 1111 1112 return size; 1113 1114err_event_drop: 1115 /* got signal: force tx state machine to be idle */ 1116 so->tx.state = ISOTP_IDLE; 1117 hrtimer_cancel(&so->txfrtimer); 1118 hrtimer_cancel(&so->txtimer); 1119err_out_drop: 1120 /* drop this PDU and unlock a potential wait queue */ 1121 so->tx.state = ISOTP_IDLE; 1122 wake_up_interruptible(&so->wait); 1123 1124 return err; 1125} 1126 1127static int isotp_recvmsg(struct socket *sock, struct msghdr *msg, size_t size, 1128 int flags) 1129{ 1130 struct sock *sk = sock->sk; 1131 struct sk_buff *skb; 1132 struct isotp_sock *so = isotp_sk(sk); 1133 int ret = 0; 1134 1135 if (flags & ~(MSG_DONTWAIT | MSG_TRUNC | MSG_PEEK | MSG_CMSG_COMPAT)) 1136 return -EINVAL; 1137 1138 if (!so->bound) 1139 return -EADDRNOTAVAIL; 1140 1141 skb = skb_recv_datagram(sk, flags, &ret); 1142 if (!skb) 1143 return ret; 1144 1145 if (size < skb->len) 1146 msg->msg_flags |= MSG_TRUNC; 1147 else 1148 size = skb->len; 1149 1150 ret = memcpy_to_msg(msg, skb->data, size); 1151 if (ret < 0) 1152 goto out_err; 1153 1154 sock_recv_cmsgs(msg, sk, skb); 1155 1156 if (msg->msg_name) { 1157 __sockaddr_check_size(ISOTP_MIN_NAMELEN); 1158 msg->msg_namelen = ISOTP_MIN_NAMELEN; 1159 memcpy(msg->msg_name, skb->cb, msg->msg_namelen); 1160 } 1161 1162 /* set length of return value */ 1163 ret = (flags & MSG_TRUNC) ? skb->len : size; 1164 1165out_err: 1166 skb_free_datagram(sk, skb); 1167 1168 return ret; 1169} 1170 1171static int isotp_release(struct socket *sock) 1172{ 1173 struct sock *sk = sock->sk; 1174 struct isotp_sock *so; 1175 struct net *net; 1176 1177 if (!sk) 1178 return 0; 1179 1180 so = isotp_sk(sk); 1181 net = sock_net(sk); 1182 1183 /* wait for complete transmission of current pdu */ 1184 while (wait_event_interruptible(so->wait, so->tx.state == ISOTP_IDLE) == 0 && 1185 cmpxchg(&so->tx.state, ISOTP_IDLE, ISOTP_SHUTDOWN) != ISOTP_IDLE) 1186 ; 1187 1188 /* force state machines to be idle also when a signal occurred */ 1189 so->tx.state = ISOTP_SHUTDOWN; 1190 so->rx.state = ISOTP_IDLE; 1191 1192 spin_lock(&isotp_notifier_lock); 1193 while (isotp_busy_notifier == so) { 1194 spin_unlock(&isotp_notifier_lock); 1195 schedule_timeout_uninterruptible(1); 1196 spin_lock(&isotp_notifier_lock); 1197 } 1198 list_del(&so->notifier); 1199 spin_unlock(&isotp_notifier_lock); 1200 1201 lock_sock(sk); 1202 1203 /* remove current filters & unregister */ 1204 if (so->bound) { 1205 if (so->ifindex) { 1206 struct net_device *dev; 1207 1208 dev = dev_get_by_index(net, so->ifindex); 1209 if (dev) { 1210 if (isotp_register_rxid(so)) 1211 can_rx_unregister(net, dev, so->rxid, 1212 SINGLE_MASK(so->rxid), 1213 isotp_rcv, sk); 1214 1215 can_rx_unregister(net, dev, so->txid, 1216 SINGLE_MASK(so->txid), 1217 isotp_rcv_echo, sk); 1218 dev_put(dev); 1219 synchronize_rcu(); 1220 } 1221 } 1222 } 1223 1224 hrtimer_cancel(&so->txfrtimer); 1225 hrtimer_cancel(&so->txtimer); 1226 hrtimer_cancel(&so->rxtimer); 1227 1228 so->ifindex = 0; 1229 so->bound = 0; 1230 1231 if (so->rx.buf != so->rx.sbuf) 1232 kfree(so->rx.buf); 1233 1234 if (so->tx.buf != so->tx.sbuf) 1235 kfree(so->tx.buf); 1236 1237 sock_orphan(sk); 1238 sock->sk = NULL; 1239 1240 release_sock(sk); 1241 sock_put(sk); 1242 1243 return 0; 1244} 1245 1246static int isotp_bind(struct socket *sock, struct sockaddr *uaddr, int len) 1247{ 1248 struct sockaddr_can *addr = (struct sockaddr_can *)uaddr; 1249 struct sock *sk = sock->sk; 1250 struct isotp_sock *so = isotp_sk(sk); 1251 struct net *net = sock_net(sk); 1252 int ifindex; 1253 struct net_device *dev; 1254 canid_t tx_id = addr->can_addr.tp.tx_id; 1255 canid_t rx_id = addr->can_addr.tp.rx_id; 1256 int err = 0; 1257 int notify_enetdown = 0; 1258 1259 if (len < ISOTP_MIN_NAMELEN) 1260 return -EINVAL; 1261 1262 if (addr->can_family != AF_CAN) 1263 return -EINVAL; 1264 1265 /* sanitize tx CAN identifier */ 1266 if (tx_id & CAN_EFF_FLAG) 1267 tx_id &= (CAN_EFF_FLAG | CAN_EFF_MASK); 1268 else 1269 tx_id &= CAN_SFF_MASK; 1270 1271 /* give feedback on wrong CAN-ID value */ 1272 if (tx_id != addr->can_addr.tp.tx_id) 1273 return -EINVAL; 1274 1275 /* sanitize rx CAN identifier (if needed) */ 1276 if (isotp_register_rxid(so)) { 1277 if (rx_id & CAN_EFF_FLAG) 1278 rx_id &= (CAN_EFF_FLAG | CAN_EFF_MASK); 1279 else 1280 rx_id &= CAN_SFF_MASK; 1281 1282 /* give feedback on wrong CAN-ID value */ 1283 if (rx_id != addr->can_addr.tp.rx_id) 1284 return -EINVAL; 1285 } 1286 1287 if (!addr->can_ifindex) 1288 return -ENODEV; 1289 1290 lock_sock(sk); 1291 1292 if (so->bound) { 1293 err = -EINVAL; 1294 goto out; 1295 } 1296 1297 /* ensure different CAN IDs when the rx_id is to be registered */ 1298 if (isotp_register_rxid(so) && rx_id == tx_id) { 1299 err = -EADDRNOTAVAIL; 1300 goto out; 1301 } 1302 1303 dev = dev_get_by_index(net, addr->can_ifindex); 1304 if (!dev) { 1305 err = -ENODEV; 1306 goto out; 1307 } 1308 if (dev->type != ARPHRD_CAN) { 1309 dev_put(dev); 1310 err = -ENODEV; 1311 goto out; 1312 } 1313 if (dev->mtu < so->ll.mtu) { 1314 dev_put(dev); 1315 err = -EINVAL; 1316 goto out; 1317 } 1318 if (!(dev->flags & IFF_UP)) 1319 notify_enetdown = 1; 1320 1321 ifindex = dev->ifindex; 1322 1323 if (isotp_register_rxid(so)) 1324 can_rx_register(net, dev, rx_id, SINGLE_MASK(rx_id), 1325 isotp_rcv, sk, "isotp", sk); 1326 1327 /* no consecutive frame echo skb in flight */ 1328 so->cfecho = 0; 1329 1330 /* register for echo skb's */ 1331 can_rx_register(net, dev, tx_id, SINGLE_MASK(tx_id), 1332 isotp_rcv_echo, sk, "isotpe", sk); 1333 1334 dev_put(dev); 1335 1336 /* switch to new settings */ 1337 so->ifindex = ifindex; 1338 so->rxid = rx_id; 1339 so->txid = tx_id; 1340 so->bound = 1; 1341 1342out: 1343 release_sock(sk); 1344 1345 if (notify_enetdown) { 1346 sk->sk_err = ENETDOWN; 1347 if (!sock_flag(sk, SOCK_DEAD)) 1348 sk_error_report(sk); 1349 } 1350 1351 return err; 1352} 1353 1354static int isotp_getname(struct socket *sock, struct sockaddr *uaddr, int peer) 1355{ 1356 struct sockaddr_can *addr = (struct sockaddr_can *)uaddr; 1357 struct sock *sk = sock->sk; 1358 struct isotp_sock *so = isotp_sk(sk); 1359 1360 if (peer) 1361 return -EOPNOTSUPP; 1362 1363 memset(addr, 0, ISOTP_MIN_NAMELEN); 1364 addr->can_family = AF_CAN; 1365 addr->can_ifindex = so->ifindex; 1366 addr->can_addr.tp.rx_id = so->rxid; 1367 addr->can_addr.tp.tx_id = so->txid; 1368 1369 return ISOTP_MIN_NAMELEN; 1370} 1371 1372static int isotp_setsockopt_locked(struct socket *sock, int level, int optname, 1373 sockptr_t optval, unsigned int optlen) 1374{ 1375 struct sock *sk = sock->sk; 1376 struct isotp_sock *so = isotp_sk(sk); 1377 int ret = 0; 1378 1379 if (so->bound) 1380 return -EISCONN; 1381 1382 switch (optname) { 1383 case CAN_ISOTP_OPTS: 1384 if (optlen != sizeof(struct can_isotp_options)) 1385 return -EINVAL; 1386 1387 if (copy_from_sockptr(&so->opt, optval, optlen)) 1388 return -EFAULT; 1389 1390 /* no separate rx_ext_address is given => use ext_address */ 1391 if (!(so->opt.flags & CAN_ISOTP_RX_EXT_ADDR)) 1392 so->opt.rx_ext_address = so->opt.ext_address; 1393 1394 /* these broadcast flags are not allowed together */ 1395 if (isotp_bc_flags(so) == ISOTP_ALL_BC_FLAGS) { 1396 /* CAN_ISOTP_SF_BROADCAST is prioritized */ 1397 so->opt.flags &= ~CAN_ISOTP_CF_BROADCAST; 1398 1399 /* give user feedback on wrong config attempt */ 1400 ret = -EINVAL; 1401 } 1402 1403 /* check for frame_txtime changes (0 => no changes) */ 1404 if (so->opt.frame_txtime) { 1405 if (so->opt.frame_txtime == CAN_ISOTP_FRAME_TXTIME_ZERO) 1406 so->frame_txtime = 0; 1407 else 1408 so->frame_txtime = so->opt.frame_txtime; 1409 } 1410 break; 1411 1412 case CAN_ISOTP_RECV_FC: 1413 if (optlen != sizeof(struct can_isotp_fc_options)) 1414 return -EINVAL; 1415 1416 if (copy_from_sockptr(&so->rxfc, optval, optlen)) 1417 return -EFAULT; 1418 break; 1419 1420 case CAN_ISOTP_TX_STMIN: 1421 if (optlen != sizeof(u32)) 1422 return -EINVAL; 1423 1424 if (copy_from_sockptr(&so->force_tx_stmin, optval, optlen)) 1425 return -EFAULT; 1426 break; 1427 1428 case CAN_ISOTP_RX_STMIN: 1429 if (optlen != sizeof(u32)) 1430 return -EINVAL; 1431 1432 if (copy_from_sockptr(&so->force_rx_stmin, optval, optlen)) 1433 return -EFAULT; 1434 break; 1435 1436 case CAN_ISOTP_LL_OPTS: 1437 if (optlen == sizeof(struct can_isotp_ll_options)) { 1438 struct can_isotp_ll_options ll; 1439 1440 if (copy_from_sockptr(&ll, optval, optlen)) 1441 return -EFAULT; 1442 1443 /* check for correct ISO 11898-1 DLC data length */ 1444 if (ll.tx_dl != padlen(ll.tx_dl)) 1445 return -EINVAL; 1446 1447 if (ll.mtu != CAN_MTU && ll.mtu != CANFD_MTU) 1448 return -EINVAL; 1449 1450 if (ll.mtu == CAN_MTU && 1451 (ll.tx_dl > CAN_MAX_DLEN || ll.tx_flags != 0)) 1452 return -EINVAL; 1453 1454 memcpy(&so->ll, &ll, sizeof(ll)); 1455 1456 /* set ll_dl for tx path to similar place as for rx */ 1457 so->tx.ll_dl = ll.tx_dl; 1458 } else { 1459 return -EINVAL; 1460 } 1461 break; 1462 1463 default: 1464 ret = -ENOPROTOOPT; 1465 } 1466 1467 return ret; 1468} 1469 1470static int isotp_setsockopt(struct socket *sock, int level, int optname, 1471 sockptr_t optval, unsigned int optlen) 1472 1473{ 1474 struct sock *sk = sock->sk; 1475 int ret; 1476 1477 if (level != SOL_CAN_ISOTP) 1478 return -EINVAL; 1479 1480 lock_sock(sk); 1481 ret = isotp_setsockopt_locked(sock, level, optname, optval, optlen); 1482 release_sock(sk); 1483 return ret; 1484} 1485 1486static int isotp_getsockopt(struct socket *sock, int level, int optname, 1487 char __user *optval, int __user *optlen) 1488{ 1489 struct sock *sk = sock->sk; 1490 struct isotp_sock *so = isotp_sk(sk); 1491 int len; 1492 void *val; 1493 1494 if (level != SOL_CAN_ISOTP) 1495 return -EINVAL; 1496 if (get_user(len, optlen)) 1497 return -EFAULT; 1498 if (len < 0) 1499 return -EINVAL; 1500 1501 switch (optname) { 1502 case CAN_ISOTP_OPTS: 1503 len = min_t(int, len, sizeof(struct can_isotp_options)); 1504 val = &so->opt; 1505 break; 1506 1507 case CAN_ISOTP_RECV_FC: 1508 len = min_t(int, len, sizeof(struct can_isotp_fc_options)); 1509 val = &so->rxfc; 1510 break; 1511 1512 case CAN_ISOTP_TX_STMIN: 1513 len = min_t(int, len, sizeof(u32)); 1514 val = &so->force_tx_stmin; 1515 break; 1516 1517 case CAN_ISOTP_RX_STMIN: 1518 len = min_t(int, len, sizeof(u32)); 1519 val = &so->force_rx_stmin; 1520 break; 1521 1522 case CAN_ISOTP_LL_OPTS: 1523 len = min_t(int, len, sizeof(struct can_isotp_ll_options)); 1524 val = &so->ll; 1525 break; 1526 1527 default: 1528 return -ENOPROTOOPT; 1529 } 1530 1531 if (put_user(len, optlen)) 1532 return -EFAULT; 1533 if (copy_to_user(optval, val, len)) 1534 return -EFAULT; 1535 return 0; 1536} 1537 1538static void isotp_notify(struct isotp_sock *so, unsigned long msg, 1539 struct net_device *dev) 1540{ 1541 struct sock *sk = &so->sk; 1542 1543 if (!net_eq(dev_net(dev), sock_net(sk))) 1544 return; 1545 1546 if (so->ifindex != dev->ifindex) 1547 return; 1548 1549 switch (msg) { 1550 case NETDEV_UNREGISTER: 1551 lock_sock(sk); 1552 /* remove current filters & unregister */ 1553 if (so->bound) { 1554 if (isotp_register_rxid(so)) 1555 can_rx_unregister(dev_net(dev), dev, so->rxid, 1556 SINGLE_MASK(so->rxid), 1557 isotp_rcv, sk); 1558 1559 can_rx_unregister(dev_net(dev), dev, so->txid, 1560 SINGLE_MASK(so->txid), 1561 isotp_rcv_echo, sk); 1562 } 1563 1564 so->ifindex = 0; 1565 so->bound = 0; 1566 release_sock(sk); 1567 1568 sk->sk_err = ENODEV; 1569 if (!sock_flag(sk, SOCK_DEAD)) 1570 sk_error_report(sk); 1571 break; 1572 1573 case NETDEV_DOWN: 1574 sk->sk_err = ENETDOWN; 1575 if (!sock_flag(sk, SOCK_DEAD)) 1576 sk_error_report(sk); 1577 break; 1578 } 1579} 1580 1581static int isotp_notifier(struct notifier_block *nb, unsigned long msg, 1582 void *ptr) 1583{ 1584 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 1585 1586 if (dev->type != ARPHRD_CAN) 1587 return NOTIFY_DONE; 1588 if (msg != NETDEV_UNREGISTER && msg != NETDEV_DOWN) 1589 return NOTIFY_DONE; 1590 if (unlikely(isotp_busy_notifier)) /* Check for reentrant bug. */ 1591 return NOTIFY_DONE; 1592 1593 spin_lock(&isotp_notifier_lock); 1594 list_for_each_entry(isotp_busy_notifier, &isotp_notifier_list, notifier) { 1595 spin_unlock(&isotp_notifier_lock); 1596 isotp_notify(isotp_busy_notifier, msg, dev); 1597 spin_lock(&isotp_notifier_lock); 1598 } 1599 isotp_busy_notifier = NULL; 1600 spin_unlock(&isotp_notifier_lock); 1601 return NOTIFY_DONE; 1602} 1603 1604static int isotp_init(struct sock *sk) 1605{ 1606 struct isotp_sock *so = isotp_sk(sk); 1607 1608 so->ifindex = 0; 1609 so->bound = 0; 1610 1611 so->opt.flags = CAN_ISOTP_DEFAULT_FLAGS; 1612 so->opt.ext_address = CAN_ISOTP_DEFAULT_EXT_ADDRESS; 1613 so->opt.rx_ext_address = CAN_ISOTP_DEFAULT_EXT_ADDRESS; 1614 so->opt.rxpad_content = CAN_ISOTP_DEFAULT_PAD_CONTENT; 1615 so->opt.txpad_content = CAN_ISOTP_DEFAULT_PAD_CONTENT; 1616 so->opt.frame_txtime = CAN_ISOTP_DEFAULT_FRAME_TXTIME; 1617 so->frame_txtime = CAN_ISOTP_DEFAULT_FRAME_TXTIME; 1618 so->rxfc.bs = CAN_ISOTP_DEFAULT_RECV_BS; 1619 so->rxfc.stmin = CAN_ISOTP_DEFAULT_RECV_STMIN; 1620 so->rxfc.wftmax = CAN_ISOTP_DEFAULT_RECV_WFTMAX; 1621 so->ll.mtu = CAN_ISOTP_DEFAULT_LL_MTU; 1622 so->ll.tx_dl = CAN_ISOTP_DEFAULT_LL_TX_DL; 1623 so->ll.tx_flags = CAN_ISOTP_DEFAULT_LL_TX_FLAGS; 1624 1625 /* set ll_dl for tx path to similar place as for rx */ 1626 so->tx.ll_dl = so->ll.tx_dl; 1627 1628 so->rx.state = ISOTP_IDLE; 1629 so->tx.state = ISOTP_IDLE; 1630 1631 so->rx.buf = so->rx.sbuf; 1632 so->tx.buf = so->tx.sbuf; 1633 so->rx.buflen = ARRAY_SIZE(so->rx.sbuf); 1634 so->tx.buflen = ARRAY_SIZE(so->tx.sbuf); 1635 1636 hrtimer_init(&so->rxtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL_SOFT); 1637 so->rxtimer.function = isotp_rx_timer_handler; 1638 hrtimer_init(&so->txtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL_SOFT); 1639 so->txtimer.function = isotp_tx_timer_handler; 1640 hrtimer_init(&so->txfrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL_SOFT); 1641 so->txfrtimer.function = isotp_txfr_timer_handler; 1642 1643 init_waitqueue_head(&so->wait); 1644 spin_lock_init(&so->rx_lock); 1645 1646 spin_lock(&isotp_notifier_lock); 1647 list_add_tail(&so->notifier, &isotp_notifier_list); 1648 spin_unlock(&isotp_notifier_lock); 1649 1650 return 0; 1651} 1652 1653static __poll_t isotp_poll(struct file *file, struct socket *sock, poll_table *wait) 1654{ 1655 struct sock *sk = sock->sk; 1656 struct isotp_sock *so = isotp_sk(sk); 1657 1658 __poll_t mask = datagram_poll(file, sock, wait); 1659 poll_wait(file, &so->wait, wait); 1660 1661 /* Check for false positives due to TX state */ 1662 if ((mask & EPOLLWRNORM) && (so->tx.state != ISOTP_IDLE)) 1663 mask &= ~(EPOLLOUT | EPOLLWRNORM); 1664 1665 return mask; 1666} 1667 1668static int isotp_sock_no_ioctlcmd(struct socket *sock, unsigned int cmd, 1669 unsigned long arg) 1670{ 1671 /* no ioctls for socket layer -> hand it down to NIC layer */ 1672 return -ENOIOCTLCMD; 1673} 1674 1675static const struct proto_ops isotp_ops = { 1676 .family = PF_CAN, 1677 .release = isotp_release, 1678 .bind = isotp_bind, 1679 .connect = sock_no_connect, 1680 .socketpair = sock_no_socketpair, 1681 .accept = sock_no_accept, 1682 .getname = isotp_getname, 1683 .poll = isotp_poll, 1684 .ioctl = isotp_sock_no_ioctlcmd, 1685 .gettstamp = sock_gettstamp, 1686 .listen = sock_no_listen, 1687 .shutdown = sock_no_shutdown, 1688 .setsockopt = isotp_setsockopt, 1689 .getsockopt = isotp_getsockopt, 1690 .sendmsg = isotp_sendmsg, 1691 .recvmsg = isotp_recvmsg, 1692 .mmap = sock_no_mmap, 1693}; 1694 1695static struct proto isotp_proto __read_mostly = { 1696 .name = "CAN_ISOTP", 1697 .owner = THIS_MODULE, 1698 .obj_size = sizeof(struct isotp_sock), 1699 .init = isotp_init, 1700}; 1701 1702static const struct can_proto isotp_can_proto = { 1703 .type = SOCK_DGRAM, 1704 .protocol = CAN_ISOTP, 1705 .ops = &isotp_ops, 1706 .prot = &isotp_proto, 1707}; 1708 1709static struct notifier_block canisotp_notifier = { 1710 .notifier_call = isotp_notifier 1711}; 1712 1713static __init int isotp_module_init(void) 1714{ 1715 int err; 1716 1717 max_pdu_size = max_t(unsigned int, max_pdu_size, MAX_12BIT_PDU_SIZE); 1718 max_pdu_size = min_t(unsigned int, max_pdu_size, MAX_PDU_SIZE); 1719 1720 pr_info("can: isotp protocol (max_pdu_size %d)\n", max_pdu_size); 1721 1722 err = can_proto_register(&isotp_can_proto); 1723 if (err < 0) 1724 pr_err("can: registration of isotp protocol failed %pe\n", ERR_PTR(err)); 1725 else 1726 register_netdevice_notifier(&canisotp_notifier); 1727 1728 return err; 1729} 1730 1731static __exit void isotp_module_exit(void) 1732{ 1733 can_proto_unregister(&isotp_can_proto); 1734 unregister_netdevice_notifier(&canisotp_notifier); 1735} 1736 1737module_init(isotp_module_init); 1738module_exit(isotp_module_exit); 1739