hartkopp/can-isotp

============================================================================

README.isotp

CREDITS

This repository contains a rework to simplify the build of the former ISO-TP
development repository at https://github.com/hartkopp/can-isotp-modules.

The build and repository cleanup provided by Nathan L. Conrad  was merged from
https://github.com/downwith/linux-isotp . Thanks Nathan!

DOWNLOAD and BUILD

1. Download repository and enter the repositories root directory

      git clone https://github.com/hartkopp/can-isotp.git

      cd can-isotp

2. Build ISO-TP kernel module

   Ensure build dependencies are installed. E.g. for Debian (or Ubuntu):

      sudo apt-get install build-essential linux-headers-$(uname -r)

   To build:

      (you need to be in the repositories root path)

      make

   To install (optional):

      sudo make modules_install


3. When the PF_CAN core module is loaded ('modprobe can') the ISO-TP module
   can be loaded into the kernel with

       insmod ./net/can/can-isotp.ko

   When the can-isotp.ko module has been installed into the Linux Kernels
   modules directory (e.g. with 'make modules_install') the module should
   load automatically when opening a CAN_ISOTP socket.

   Note: on UEFI systems with Secure Boot enabled, it is not possible to insert
   unsigned kernel modules. One option is to sign them manually. The comments
   linked below can help you in the process:
   #25 (comment)
   #25 (comment)

----------------------------------------------------------------------------

Readme file for ISO 15765-2 CAN transport protocol for protocol family CAN

* This implementation is already widely used in automotive use-cases, e.g.
* for UDS based OBD diagnosis. Although some small adaptions may be applied
* to make it ready for Linux Mainline. Feedback is welcome.
*
* Current behaviour:
*
* - no ISO-TP specific return values are provided to the userspace
* - when a transfer (tx) is on the run the next write() blocks until it's done
* - no support for sending wait frames to the data source in the rx path


  1 What is ISO-TP for CAN

  2 Tools and Examples
    2.1 isotpsend - send PDUs from stdin to CAN
    2.2 isotprecv - print received PDU on stdout
    2.3 isotpdump - dump CAN frames with PCI decoding (using CAN_RAW socket)
    2.4 isotpsniffer - dump reassembled ISO-TP PDUs (using CAN_ISOTP socket)
    2.5 isotptun - create an IP tunnel over unreliable ISO-TP PDUs

  3 Remarks
    3.1 tx_queue_len on real CAN busses (!!!)
    3.2 State of the Socket API & Discussion

1 What is ISO-TP for CAN
------------------------

  CAN Transport Protocols offer support for segmented Point-to-Point
  communication between CAN nodes via two defined CAN Identifiers.
  This protocol driver implements data transfers according ISO 15765-2.

  CAN ISO-TP is an unreliable datagram protocol and is implemented like this.
  For that reason error indications, like 'dropped PDUs in the receive path due
  to wrong SequenceNumbers' are intentionally not supported.
  See discussion in section 3.2

  Code examples of how to use ISO-TP sockets can be found in the source code
  of the available tools described below. The API is still a RFC and will be
  described in detail later, when it's finalized.


2 Tools and Examples
--------------------

  The source code of these tools can be found in the can-utils repository
  on GitHub at https://github.com/linux-can/can-utils

  For the examples below we assume a test setup with two hosts:

         _______          _______ 
        |       |        |       |
        | Host1 |        | Host2 |
        |       |        |       |
        | can1  |        | can2  |
        |_______|        |_______|
            |                |
     |------------------------------| CAN bus


  2.1 isotpsend - send PDUs from stdin to CAN

  isotpsend gives this help when invoked without any parameters:

  Usage: isotpsend [options] <CAN interface>
  Options: -s <can_id>  (source can_id. Use 8 digits for extended IDs)
           -d <can_id>  (destination can_id. Use 8 digits for extended IDs)
           -x <addr>    (extended addressing mode. Use 'any' for all addresses)
           -p <byte>    (set and enable padding byte)
           -P <mode>    (check padding in FC. (l)ength (c)ontent (a)ll)
           -t <time ns> (transmit time in nanosecs)

  CAN IDs and addresses are given and expected in hexadecimal values.
  The pdu data is expected on STDIN in space separated ASCII hex values.
  
  Example (send ISOTP PDU from Host2 to Host1):
  echo 11 22 33 44 55 66 DE AD BE EF | isotpsend -s 321 -d 123 can2


  2.2 isotprecv - print received PDU on stdout

  isotprecv gives this help when invoked without any parameters:

  Usage: isotprecv [options] <CAN interface>
  Options: -s <can_id>  (source can_id. Use 8 digits for extended IDs)
           -d <can_id>  (destination can_id. Use 8 digits for extended IDs)
           -x <addr>    (extended addressing mode.)
           -p <byte>    (set and enable padding byte)
           -P <mode>    (check padding in SF/CF. (l)ength (c)ontent (a)ll)
           -b <bs>      (blocksize. 0 = off)
           -m <val>     (STmin in ms/ns. See spec.)
           -w <num>     (max. wait frame transmissions.)
           -l           (loop: do not exit after pdu receiption.)

  CAN IDs and addresses are given and expected in hexadecimal values.
  The pdu data is written on STDOUT in space separated ASCII hex values.

  Example (receive ISOTP PDU from Host2 on Host1):
  isotprecv -s 123 -d 321 -l can1

  In this example '-l' is set which causes isotprecv to continue listening on
  the given connection after printing a received PDU.


  2.3 isotpdump - dump CAN frames with PCI decoding (using CAN_RAW socket)

  isotpdump gives this help when invoked without any parameters:

  Usage: isotpdump [options] <CAN interface>
  Options: -s <can_id> (source can_id. Use 8 digits for extended IDs)
           -d <can_id> (destination can_id. Use 8 digits for extended IDs)
           -x <addr>   (extended addressing mode. Use 'any' for all addresses)
           -c          (color mode)
           -a          (print data also in ASCII-chars)
           -t <type>   (timestamp: (a)bsolute/(d)elta/(z)ero/(A)bsolute w date)

  CAN IDs and addresses are given and expected in hexadecimal values.

  Example (dump CAN Frames on Host1):
  isotpdump -s 123 -d 321 -c -ta can1


  2.4 isotpsniffer - dump reassembled ISO-TP PDUs (using CAN_ISOTP socket)

  The difference to isotpdump is, that isotpsniffer opens two CAN_ISOTP
  sockets and sets the CAN_ISOTP_LISTEN_MODE flag on both of these sockets.
  This causes the ISO-TP protocol driver to reassemble the received data but
  not send and flow control frames on the CAN bus.

  isotpsniffer gives this help when invoked without any parameters:

  Usage: isotpsniffer [options] <CAN interface>
  Options: -s <can_id> (source can_id. Use 8 digits for extended IDs)
           -d <can_id> (destination can_id. Use 8 digits for extended IDs)
           -x <addr>   (extended addressing mode.)
           -c          (color mode)
           -t <type>   (timestamp: (a)bsolute/(d)elta/(z)ero/(A)bsolute w date)
           -f <format> (1 = HEX, 2 = ASCII, 3 = HEX & ASCII - default: 3)
           -h <len>    (head: print only first <len> bytes)

  CAN IDs and addresses are given and expected in hexadecimal values.

  Example (dump reassembled ISO-TP PDUs on Host1):
  isotpsniffer -s 123 -d 321 -c -ta can1


  2.5 isotptun - create an IP tunnel over unreliable ISO-TP PDUs

  The ISO-TP provides an unreliable datagram protocol with PDU sizes up to
  4095 bytes. Having Linux tunnel driver in mind creating an IP over ISO-TP
  tunnel became obvious - so here it is ;-)

  From linux/Documentation/networking/tuntap.txt:
  TUN/TAP provides packet reception and transmission for user space programs. 
  It can be seen as a simple Point-to-Point or Ethernet device, which,
  instead of receiving packets from physical media, receives them from 
  user space program and instead of sending packets via physical media 
  writes them to the user space program. 

  isotptun gives this help when invoked without any parameters:

  Usage: isotptun [options] <CAN interface>

  This program creates a Linux tunnel netdevice 'ctunX' and transfers the
  ethernet frames inside ISO15765-2 (unreliable) datagrams on CAN.

  Options: -s <can_id>  (source can_id. Use 8 digits for extended IDs)
           -d <can_id>  (destination can_id. Use 8 digits for extended IDs)
           -x <addr>    (extended addressing mode.)
           -p <byte>    (padding byte rx path)
           -q <byte>    (padding byte tx path)
           -P <mode>    (check padding. (l)ength (c)ontent (a)ll)
           -t <time ns> (transmit time in nanosecs)
           -b <bs>      (blocksize. 0 = off)
           -m <val>     (STmin in ms/ns. See spec.)
           -w <num>     (max. wait frame transmissions.)
           -h           (half duplex mode.)
           -v           (verbose mode. Print symbols for tunneled msgs.)

  CAN IDs and addresses are given and expected in hexadecimal values.
  Use e.g. 'ifconfig ctun0 123.123.123.1 pointopoint 123.123.123.2 up'
  to create a point-to-point IP connection on CAN.

  Example:

  on Host1 run as root:
  isotptun -s 123 -d 321 -v can1 (this blocks, so use a separate terminal)

  ifconfig ctun0 123.123.123.1 pointopoint 123.123.123.2 up

  on Host2 run as root:
  isotptun -s 321 -d 123 -v can2 (this blocks, so use a separate terminal)

  ifconfig ctun0 123.123.123.2 pointopoint 123.123.123.1 up

  Have fun (like in early modem dialup days):
  ping 123.123.123.1
  ssh [email protected]
  scp [email protected]:myfile.tar.gz .

  scp get's about 27kByte/s over a 500kbit/s CAN interface.


3 Remarks
---------

  3.1 tx_queue_len on real CAN busses (!!!)

  The blocksize (BS) splits the CAN frame stream into chunks that need to be
  acknowledged on the receiver side with a flow control frame. In the case
  the blocksize is set to zero the protocol does not wait for flow control
  frames and sends all the CAN frames for the ISO-TP PDU in one burst.

  In the case of a 4095 bytes PDU the protocol driver must create 586(!)
  CAN frames, that are pushed into the CAN network device. This is no problem
  with virtual CAN devices (vcan) but for real CAN devices with real bus
  timings. Even though the frame_txtime (N_As/N_Ar) can be set in the ISO-TP
  socket options, it is recommended to have an appropriate tx queue available
  in the CAN driver, e.g.:

    echo 4000 > /sys/class/net/can0/tx_queue_len

  or with the 'ip' tool from the iproute2 package

    ip link set can0 txqueuelen 4000

  3.2 State of the Socket API for this Linux CAN ISO-TP implementation

  Implementing transport protocol drivers in userspace on top of a CAN_RAW
  socket is possible but has massive drawbacks for fullfilling timing
  constrains and multi-user handling. Implementing a CAN transport protocol
  inside the Kernel brings different requirements, as ...

  - it needs to fit into a standard socket API
  - datagram sockets should always behave similar (e.g. like UDP/IP)
  - reduce user interaction to a minimal absolutely required level
  - reduce user programming interface to a minimal absolutely required level

  In the real world applications using unreliable datagram protocols recognize
  problems via timeouts. So do ISO-TP applications. So the questions is:
  What does it help for the application to know, that someone 'dropped a PDU
  in the receive path due to wrong SequenceNumbers'?

  The application does not know the (so far received) content and therefore
  gets this completely useless information to do *what* with it?

  From current applications perspective the things that have not been
  implemented have not been required so far. So this might become the
  discussion upon this implementation:

  - what is really needed and for what use-case?
  - how does this fit into standard networking and socket philosophy?

Oliver Hartkopp (2017-11-06)