canerrsim: add

Link: https://github.com/linux-can/can-utils/issues/525#issue-2311379340
Merge pull request #583 from yegorich/typos
2025-03-02 17:16:21 +01:00 · 2025-03-02 17:09:17 +01:00 · 2025-03-02 17:08:23 +01:00 · 2025-03-02 15:51:45 +01:00 · 2025-03-02 15:44:40 +01:00 · 2025-03-01 16:47:48 +01:00
37 changed files with 3193 additions and 698 deletions
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@ -42,7 +42,7 @@ jobs:

    # Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
+      uses: github/codeql-action/init@v3
      with:
        languages: ${{ matrix.language }}
        # If you wish to specify custom queries, you can do so here or in a config file.
@ -53,7 +53,7 @@ jobs:
    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
    # If this step fails, then you should remove it and run the build manually (see below)
    - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
+      uses: github/codeql-action/autobuild@v3

    # ℹ️ Command-line programs to run using the OS shell.
    # 📚 https://git.io/JvXDl
@ -67,4 +67,4 @@ jobs:
    #   make release

    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
+      uses: github/codeql-action/analyze@v3
--- a/.github/workflows/compile.yml
+++ b/.github/workflows/compile.yml
@ -17,18 +17,21 @@ jobs:
        - "debian:stable-slim"
        - "debian:testing-slim"
        - "debian:unstable-slim"
+        - "debian:experimental"

    steps:
    - uses: actions/checkout@v4

    - name: Prepare ${{ matrix.release }} container
+      env:
+        release: ${{ matrix.release == 'debian:experimental' && '-t experimental' || '' }}
      run: |
        podman version
        podman run --name stable -di --userns=keep-id:uid=1000,gid=1000 -v "$PWD":/home -w /home ${{ matrix.release }} bash
        podman exec -i stable uname -a
        podman exec -i stable id
        podman exec -i -u root stable apt update
-        podman exec -e DEBIAN_FRONTEND='noninteractive' -i -u root stable apt install -o APT::Install-Suggests=false -qy \
+        podman exec -e DEBIAN_FRONTEND='noninteractive' -i -u root stable apt install -o APT::Install-Suggests=false -qy ${release} \
                clang \
                cmake \
                gcc \
--- a/.gitignore
+++ b/.gitignore
@ -1,6 +1,12 @@
 *~
+*.a
+*.so
+*.so.*
 *.o
 .ccls-cache
+CMakeCache.txt
+CMakeFiles/
+cmake_install.cmake
 compile_commands.json
 tags
 /build
@ -31,6 +37,8 @@ tags
 /j1939cat
 /j1939spy
 /j1939sr
+/j1939-timedate-cli
+/j1939-timedate-srv
 /log2asc
 /log2long
 /mcp251xfd-dump
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -12,6 +12,10 @@ if(NOT CMAKE_BUILD_TYPE)
  set(CMAKE_BUILD_TYPE Release)
 endif()

+if(CMAKE_EXPORT_COMPILE_COMMANDS STREQUAL "")
+  set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE BOOL "project default" FORCE)
+endif()
+
 # Add an option to enable treating warnings as errors
 option(ENABLE_WERROR "Treat all compiler warnings as errors" OFF)

@ -21,7 +25,7 @@ endif()

 add_definitions(-D_GNU_SOURCE)

-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wno-parentheses")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wno-parentheses -Wsign-compare")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-strict-aliasing")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DSO_RXQ_OVFL=40")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DPF_CAN=29")
@ -62,6 +66,11 @@ set(PROGRAMS_J1939
  testj1939
 )

+set(PROGRAMS_J1939_TIMEDATE
+  j1939-timedate-srv
+  j1939-timedate-cli
+)
+
 set(PROGRAMS_ISOBUSFS
  isobusfs-srv
  isobusfs-cli
@ -69,6 +78,7 @@ set(PROGRAMS_ISOBUSFS

 set(PROGRAMS
  ${PROGRAMS_CANLIB}
+  canerrsim
  canfdtest
  cangw
  cansniffer
@ -105,6 +115,10 @@ if(NOT ANDROID)
    libj1939.c
  )

+  target_link_libraries(j1939
+    PRIVATE can
+  )
+
  add_library(isobusfs SHARED
    isobusfs/isobusfs_cmn.c
    isobusfs/isobusfs_cmn_dh.c
@ -117,6 +131,7 @@ if(NOT ANDROID)

  set_target_properties(isobusfs PROPERTIES
    PUBLIC_HEADER "${PUBLIC_HEADER_ISOBUSFS}"
+    SOVERSION 0
  )

  install(TARGETS isobusfs
@ -134,7 +149,7 @@ if(NOT ANDROID)
  )

  target_link_libraries(isobusfs-cli
-    PRIVATE isobusfs can
+    PRIVATE isobusfs can j1939
  )

  add_executable(isobusfs-srv
@ -148,13 +163,39 @@ if(NOT ANDROID)
  )

  target_link_libraries(isobusfs-srv
-    PRIVATE isobusfs can
+    PRIVATE isobusfs can j1939
  )

  install(TARGETS
    isobusfs-cli
    isobusfs-srv
    DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+  set(PUBLIC_HEADER_j1939_TIMEDATE
+    j1939_timedate/j1939_timedate_cmn.h
+  )
+
+  add_executable(j1939-timedate-cli
+    j1939_timedate/j1939_timedate_cli.c
+  )
+
+  target_link_libraries(j1939-timedate-cli
+    PRIVATE can j1939
+  )
+
+  add_executable(j1939-timedate-srv
+    j1939_timedate/j1939_timedate_srv.c
+  )
+
+  target_link_libraries(j1939-timedate-srv
+    PRIVATE can j1939
+  )
+
+  install(TARGETS
+    j1939-timedate-cli
+    j1939-timedate-srv
+    DESTINATION ${CMAKE_INSTALL_BINDIR})
+
 endif()

 add_library(can STATIC
@ -167,7 +208,7 @@ foreach(name ${PROGRAMS})

  if("${name}" IN_LIST PROGRAMS_J1939)
    target_link_libraries(${name}
-      PRIVATE j1939
+      PRIVATE j1939 can
    )
  elseif("${name}" IN_LIST PROGRAMS_CANLIB)
    target_link_libraries(${name}
--- a/46
+++ b/46
@ -63,6 +63,10 @@ CPPFLAGS += \
 PROGRAMS_CANGW := \
 	cangw

+PROGRAMS_J1939_TIMEDATE := \
+	j1939-timedate-srv \
+	j1939-timedate-cli
+
 PROGRAMS_ISOBUSFS := \
 	isobusfs-srv \
 	isobusfs-cli
@ -93,6 +97,7 @@ PROGRAMS_SLCAN := \

 PROGRAMS := \
 	$(PROGRAMS_CANGW) \
+	$(PROGRAMS_J1939_TIMEDATE) \
 	$(PROGRAMS_ISOBUSFS) \
 	$(PROGRAMS_ISOTP) \
 	$(PROGRAMS_J1939) \
@ -101,6 +106,7 @@ PROGRAMS := \
 	can-calc-bit-timing \
 	canbusload \
 	candump \
+	canerrsim \
 	canfdtest \
 	cangen \
 	cansequence \
@ -121,7 +127,7 @@ endif
 all: $(PROGRAMS)

 clean:
-	rm -f $(PROGRAMS) *.o mcp251xfd/*.o isobusfs/*.o
+	rm -f $(PROGRAMS) *.o mcp251xfd/*.o isobusfs/*.o j1939_timedate/*.o

 install:
 	mkdir -p $(DESTDIR)$(PREFIX)/bin
@ -139,13 +145,15 @@ cansend.o:	lib.h
 log2asc.o:	lib.h
 log2long.o:	lib.h
 slcanpty.o:	lib.h
-j1939acd.o:	libj1939.h
-j1939cat.o:	libj1939.h
-j1939spy.o:	libj1939.h
-j1939sr.o:	libj1939.h
-testj1939.o:	libj1939.h
-isobusfs_srv.o:	lib.h
-isobusfs_c.o:	lib.h
+j1939acd.o:	lib.h libj1939.h
+j1939cat.o:	lib.h libj1939.h
+j1939spy.o:	lib.h libj1939.h
+j1939sr.o:	lib.h libj1939.h
+testj1939.o:	lib.h libj1939.h
+isobusfs_srv.o:	lib.h libj1939.h
+isobusfs_c.o:	lib.h libj1939.h
+j1939_timedate_srv.o: lib.h libj1939.h
+j1939_timedate_cli.o: lib.h libj1939.h
 canframelen.o:  canframelen.h

 asc2log:	asc2log.o	lib.o
@ -159,13 +167,24 @@ cansequence:	cansequence.o	lib.o
 log2asc:	log2asc.o	lib.o
 log2long:	log2long.o	lib.o
 slcanpty:	slcanpty.o	lib.o
-j1939acd:	j1939acd.o	libj1939.o
-j1939cat:	j1939cat.o	libj1939.o
-j1939spy:	j1939spy.o	libj1939.o
-j1939sr:	j1939sr.o	libj1939.o
-testj1939:	testj1939.o	libj1939.o
+j1939acd:	j1939acd.o	lib.o libj1939.o
+j1939cat:	j1939cat.o	lib.o libj1939.o
+j1939spy:	j1939spy.o	lib.o libj1939.o
+j1939sr:	j1939sr.o	lib.o libj1939.o
+testj1939:	testj1939.o	lib.o libj1939.o
+
+j1939-timedate-srv:	lib.o \
+			libj1939.o \
+			j1939_timedate/j1939_timedate_srv.o
+		$(CC) $(LDFLAGS) $^ $(LDLIBS) -o $@
+
+j1939-timedate-cli:	lib.o \
+			libj1939.o \
+			j1939_timedate/j1939_timedate_cli.o
+		$(CC) $(LDFLAGS) $^ $(LDLIBS) -o $@

 isobusfs-srv:	lib.o \
+		libj1939.o \
 		isobusfs/isobusfs_cmn.o \
 		isobusfs/isobusfs_srv.o \
 		isobusfs/isobusfs_srv_cm.o \
@ -178,6 +197,7 @@ isobusfs-srv:	lib.o \
 	$(CC) $(LDFLAGS) $^ $(LDLIBS) -o $@

 isobusfs-cli:	lib.o \
+		libj1939.o \
 		isobusfs/isobusfs_cmn.o \
 		isobusfs/isobusfs_cli.o \
 		isobusfs/isobusfs_cli_cm.o \
--- a/README.md
+++ b/README.md
@ -72,7 +72,7 @@ Follow the link to see examples on how this tools can be used:

 ### Additional Information:

-*   [SocketCAN Documentation (Linux Kernel)](https://www.kernel.org/doc/Documentation/networking/can.txt)
+*   [SocketCAN Documentation (Linux Kernel)](https://www.kernel.org/doc/html/latest/networking/can.html)
 *   [Elinux.org CAN Bus Page](http://elinux.org/CAN_Bus)
 *   [Debian Package Description](https://packages.debian.org/sid/can-utils)

--- a/asc2log.c
+++ b/asc2log.c
@ -58,7 +58,17 @@

 #include "lib.h"

-#define BUFLEN 400 /* CAN FD mode lines can be pretty long */
+#define BUFLEN 6500 /* CAN XL mode lines can be pretty long */
+#define NO_DIR '.'
+
+/* relevant flags in Flags field */
+#define ASC_F_RTR 0x00000010
+#define ASC_F_FDF 0x00001000
+#define ASC_F_BRS 0x00002000
+#define ASC_F_ESI 0x00004000
+#define ASC_F_XLF 0x00400000
+#define ASC_F_RES 0x00800000
+#define ASC_F_SEC 0x01000000

 extern int optind, opterr, optopt;

@ -69,10 +79,12 @@ static void print_usage(char *prg)
 	fprintf(stderr, "Options:\n");
 	fprintf(stderr, "\t-I <infile>\t(default stdin)\n");
 	fprintf(stderr, "\t-O <outfile>\t(default stdout)\n");
+	fprintf(stderr, "\t-d (disable direction information R/T)\n");
+	fprintf(stderr, "\t-v (verbose)\n");
 }

 static void prframe(FILE *file, struct timeval *tv, int dev,
-		    struct canfd_frame *cf, char *extra_info)
+		    cu_t *cf, char dir)
 {
 	static char abuf[BUFLEN];

@ -83,19 +95,23 @@ static void prframe(FILE *file, struct timeval *tv, int dev,
 	else
 		fprintf(file, "canX ");

-	snprintf_canframe(abuf, sizeof(abuf), (cu_t *)cf, 0);
-	fprintf(file, "%s%s", abuf, extra_info);
+	snprintf_canframe(abuf, sizeof(abuf), cf, 0);
+
+	if (dir == NO_DIR)
+		fprintf(file, "%s\n", abuf);
+	else
+		fprintf(file, "%s %c\n", abuf, dir);
 }

-static void get_can_id(struct canfd_frame *cf, char *idstring, int base)
+static void get_can_id(canid_t *can_id, char *idstring, int base)
 {
 	if (idstring[strlen(idstring)-1] == 'x') {
-		cf->can_id = CAN_EFF_FLAG;
+		*can_id = CAN_EFF_FLAG;
 		idstring[strlen(idstring)-1] = 0;
 	} else
-		cf->can_id = 0;
+		*can_id = 0;
    
-	cf->can_id |= strtoul(idstring, NULL, base);
+	*can_id |= strtoul(idstring, NULL, base);
 }

 static void calc_tv(struct timeval *tv, struct timeval *read_tv,
@ -131,7 +147,7 @@ static void calc_tv(struct timeval *tv, struct timeval *read_tv,
 }

 static void eval_can(char* buf, struct timeval *date_tvp, char timestamps,
-		     char base, int dplace, FILE *outfile)
+		     char base, int dplace, int disable_dir, FILE *outfile)
 {
 	int interface;
 	static struct timeval tv; /* current frame timestamp */
@ -142,27 +158,26 @@ static void eval_can(char* buf, struct timeval *date_tvp, char timestamps,
 	int dlc = 0;
 	int len = 0;
 	int data[8];
-	char tmp1[BUFLEN];
-	char dir[3]; /* 'Rx' or 'Tx' plus terminating zero */
-	char *extra_info;
+	char idstr[21];
+	char dir[5]; /* 'Rx'/'Tx'/'TxRq' plus terminating zero */
 	int i, items;
 	unsigned long long sec, usec;

 	/* check for ErrorFrames */
-	if (sscanf(buf, "%llu.%llu %d %s",
+	if (sscanf(buf, "%llu.%llu %d %20s",
 		   &sec, &usec,
-		   &interface, tmp1) == 4) {
+		   &interface, idstr) == 4) {
 		read_tv.tv_sec = sec;
 		read_tv.tv_usec = usec;

-		if (!strncmp(tmp1, "ErrorFrame", strlen("ErrorFrame"))) {
+		if (!strncmp(idstr, "ErrorFrame", strlen("ErrorFrame"))) {

 			/* do not know more than 'Error' */
 			cf.can_id = (CAN_ERR_FLAG | CAN_ERR_BUSERROR);
 			cf.len = CAN_ERR_DLC;

 			calc_tv(&tv, &read_tv, date_tvp, timestamps, dplace);
-			prframe(outfile, &tv, interface, &cf, "\n");
+			prframe(outfile, &tv, interface, (cu_t *)&cf, NO_DIR);
 			fflush(outfile);
 			return;
 		}
@ -172,15 +187,15 @@ static void eval_can(char* buf, struct timeval *date_tvp, char timestamps,

 	/* check for CAN frames with (hexa)decimal values */
 	if (base == 'h')
-		items = sscanf(buf, "%llu.%llu %d %s %2s %c %x %x %x %x %x %x %x %x %x",
+		items = sscanf(buf, "%llu.%llu %d %20s %4s %c %x %x %x %x %x %x %x %x %x",
 			       &sec, &usec, &interface,
-			       tmp1, dir, &rtr, &dlc,
+			       idstr, dir, &rtr, &dlc,
 			       &data[0], &data[1], &data[2], &data[3],
 			       &data[4], &data[5], &data[6], &data[7]);
 	else
-		items = sscanf(buf, "%llu.%llu %d %s %2s %c %x %d %d %d %d %d %d %d %d",
+		items = sscanf(buf, "%llu.%llu %d %20s %4s %c %x %d %d %d %d %d %d %d %d",
 			       &sec, &usec, &interface,
-			       tmp1, dir, &rtr, &dlc,
+			       idstr, dir, &rtr, &dlc,
 			       &data[0], &data[1], &data[2], &data[3],
 			       &data[4], &data[5], &data[6], &data[7]);

@ -205,9 +220,9 @@ static void eval_can(char* buf, struct timeval *date_tvp, char timestamps,

 		/* check for CAN ID with (hexa)decimal value */
 		if (base == 'h')
-			get_can_id(&cf, tmp1, 16);
+			get_can_id(&cf.can_id, idstr, 16);
 		else
-			get_can_id(&cf, tmp1, 10);
+			get_can_id(&cf.can_id, idstr, 10);

 		/* dlc > 8 => len == CAN_MAX_DLEN => fill len8_dlc value */
 		if (dlc > CAN_MAX_DLC)
@ -216,6 +231,9 @@ static void eval_can(char* buf, struct timeval *date_tvp, char timestamps,
 		if (strlen(dir) != 2) /* "Rx" or "Tx" */
 			return;

+		if (disable_dir)
+			dir[0] = NO_DIR;
+
 		/* check for signed integer overflow */
 		if (dplace == 4 && read_tv.tv_usec >= INT_MAX / 100)
 			return;
@ -223,11 +241,6 @@ static void eval_can(char* buf, struct timeval *date_tvp, char timestamps,
 		if (dplace == 5 && read_tv.tv_usec >= INT_MAX / 10)
 			return;

-		if (dir[0] == 'R')
-			extra_info = " R\n";
-		else
-			extra_info = " T\n";
-
 		cf.len = len;
 		if (rtr == 'r')
 			cf.can_id |= CAN_RTR_FLAG;
@ -236,13 +249,13 @@ static void eval_can(char* buf, struct timeval *date_tvp, char timestamps,
 				cf.data[i] = data[i] & 0xFFU;

 		calc_tv(&tv, &read_tv, date_tvp, timestamps, dplace);
-		prframe(outfile, &tv, interface, &cf, extra_info);
+		prframe(outfile, &tv, interface, (cu_t *)&cf, dir[0]);
 		fflush(outfile);
 	}
 }

 static void eval_canfd(char* buf, struct timeval *date_tvp, char timestamps,
-		       int dplace, FILE *outfile)
+		       int dplace, int disable_dir, FILE *outfile)
 {
 	int interface;
 	static struct timeval tv; /* current frame timestamp */
@ -251,29 +264,33 @@ static void eval_canfd(char* buf, struct timeval *date_tvp, char timestamps,
 	unsigned char brs, esi, ctmp;
 	unsigned int flags;
 	int dlc, dlen = 0;
-	char tmp1[BUFLEN];
-	char dir[3]; /* 'Rx' or 'Tx' plus terminating zero */
-	char *extra_info;
+	char idstr[21];
+	char dir[5]; /* 'Rx'/'Tx'/'TxRq' plus terminating zero */
 	char *ptr;
 	int i;
+	int n = 0; /* sscanf consumed characters */
 	unsigned long long sec, usec;

-	/* The CANFD format is mainly in hex representation but <DataLength>
-	   and probably some content we skip anyway. Don't trust the docs! */
+	/*
+	 * The CANFD format is mainly in hex representation but <DataLength>
+	 * and probably some content we skip anyway. Don't trust the docs!
+	 */

-	/* 21.671796 CANFD   1 Tx         11  msgCanFdFr1                      1 0 a 16 \
-	   00 00 00 00 00 00 00 00 00 00 00 00 00 00 59 c0		\
-	   100000  214   223040 80000000 46500250 460a0250 20011736 20010205 */
+	/*
+	 * 21.671796 CANFD   1 Tx         11  msgCanFdFr1                      1 0 a 16 \
+	 * 00 00 00 00 00 00 00 00 00 00 00 00 00 00 59 c0		\
+	 * 100000  214   223040 80000000 46500250 460a0250 20011736 20010205
+	 */

 	/* check for valid line without symbolic name */
-	if (sscanf(buf, "%llu.%llu %*s %d %2s %s %hhx %hhx %x %d ",
+	if (sscanf(buf, "%llu.%llu %*s %d %4s %20s %hhx %hhx %x %d %n",
 		   &sec, &usec, &interface,
-		   dir, tmp1, &brs, &esi, &dlc, &dlen) != 9) {
+		   dir, idstr, &brs, &esi, &dlc, &dlen, &n) != 9) {

 		/* check for valid line with a symbolic name */
-		if (sscanf(buf, "%llu.%llu %*s %d %2s %s %*s %hhx %hhx %x %d ",
+		if (sscanf(buf, "%llu.%llu %*s %d %4s %20s %*s %hhx %hhx %x %d %n",
 			   &sec, &usec, &interface,
-			   dir, tmp1, &brs, &esi, &dlc, &dlen) != 9) {
+			   dir, idstr, &brs, &esi, &dlc, &dlen, &n) != 9) {

 			/* no valid CANFD format pattern */
 			return;
@ -290,6 +307,9 @@ static void eval_canfd(char* buf, struct timeval *date_tvp, char timestamps,
 	if (strlen(dir) != 2) /* "Rx" or "Tx" */
 		return;

+	if (disable_dir)
+		dir[0] = NO_DIR;
+
 	/* check for signed integer overflow */
 	if (dplace == 4 && read_tv.tv_usec >= INT_MAX / 100)
 		return;
@ -298,26 +318,13 @@ static void eval_canfd(char* buf, struct timeval *date_tvp, char timestamps,
 	if (dplace == 5 && read_tv.tv_usec >= INT_MAX / 10)
 		return;

-	if (dir[0] == 'R')
-		extra_info = " R\n";
-	else
-		extra_info = " T\n";
-
 	/* don't trust ASCII content - sanitize data length */
 	if (dlen != can_fd_dlc2len(can_fd_len2dlc(dlen)))
 		return;

-	get_can_id(&cf, tmp1, 16);
+	get_can_id(&cf.can_id, idstr, 16);

-	/* now search for the beginning of the data[] content */
-	sprintf(tmp1, " %x %x %x %2d ", brs, esi, dlc, dlen);
-
-	/* search for the pattern generated by real data */
-	ptr = strcasestr(buf, tmp1);
-	if (ptr == NULL)
-		return;
-
-	ptr += strlen(tmp1); /* start of ASCII hex frame data */
+	ptr = buf + n; /* start of ASCII hex frame data */

 	cf.len = dlen;

@ -341,12 +348,6 @@ static void eval_canfd(char* buf, struct timeval *date_tvp, char timestamps,
 	if (sscanf(ptr, "   %*x %*x %x ", &flags) != 1)
 		return;

-	/* relevant flags in Flags field */
-#define ASC_F_RTR 0x00000010
-#define ASC_F_FDF 0x00001000
-#define ASC_F_BRS 0x00002000
-#define ASC_F_ESI 0x00004000
-
 	if (flags & ASC_F_FDF) {
 		cf.flags = CANFD_FDF;
 		if (flags & ASC_F_BRS)
@ -373,18 +374,414 @@ static void eval_canfd(char* buf, struct timeval *date_tvp, char timestamps,
 	}

 	calc_tv(&tv, &read_tv, date_tvp, timestamps, dplace);
-	prframe(outfile, &tv, interface, &cf, extra_info);
+	prframe(outfile, &tv, interface, (cu_t *)&cf, dir[0]);
 	fflush(outfile);

 	/* No support for really strange CANFD ErrorFrames format m( */
 }

+static void eval_canxl_cc(char* buf, struct timeval *date_tvp, char timestamps,
+			  int dplace, int disable_dir, FILE *outfile)
+{
+	int interface;
+	static struct timeval tv; /* current frame timestamp */
+	static struct timeval read_tv; /* frame timestamp from ASC file */
+	struct can_frame cf = { 0 };
+	unsigned char ctmp;
+	unsigned int flags;
+	int dlc, dlen = 0;
+	char idstr[21];
+	char dir[5]; /* 'Rx'/'Tx'/'TxRq' plus terminating zero */
+	char *ptr;
+	int i;
+	int n = 0; /* sscanf consumed characters */
+	unsigned long long sec, usec;
+
+	/*
+	 * 59.171614 CANXL   2 Rx   CBFF   243215   176      432  msgCanCCTest1 \
+	 * f 8 e1 89 e8 c2 b9 6d 5a f1 174 00000000 00000000		\
+	 * 000000050005000e 0000000000a00010 0000000a000a001d		\
+	 * 0000000000a00002 000000100010000f 000000000a00001
+	 */
+
+	/* check for valid line without symbolic name */
+	if (sscanf(buf,
+		   "%llu.%llu %*s %d %4s " /* time, CANXL, channel, direction */
+		   "%*s %*s %*s %20s " /* frame format, msg dur, bit count, ID */
+		   "%x %d %n", /* DLC, Datalen */
+		   &sec, &usec, &interface, dir,
+		   idstr,
+		   &dlc, &dlen, &n) != 7) {
+		/* check for valid line with a symbolic name */
+		if (sscanf(buf,
+			   "%llu.%llu %*s %d %4s " /* time, CANXL, channel, direction */
+			   "%*s %*s %*s %20s " /* frame format, msg dur, bit count, ID */
+			   "%*s %x %d %n", /* sym name, DLC, Datalen */
+			   &sec, &usec, &interface, dir,
+			   idstr,
+			   &dlc, &dlen, &n) != 7) {
+			/* no valid CAN CC format pattern */
+			return;
+		}
+	}
+
+	read_tv.tv_sec = sec;
+	read_tv.tv_usec = usec;
+
+	/* check for allowed (unsigned) value ranges */
+	if ((dlen > CAN_MAX_DLEN) || (dlc > CAN_MAX_RAW_DLC))
+		return;
+
+	if (strlen(dir) != 2) /* "Rx" or "Tx" */
+		return;
+
+	if (disable_dir)
+		dir[0] = NO_DIR;
+
+	/* check for signed integer overflow */
+	if (dplace == 4 && read_tv.tv_usec >= INT_MAX / 100)
+		return;
+
+	/* check for signed integer overflow */
+	if (dplace == 5 && read_tv.tv_usec >= INT_MAX / 10)
+		return;
+
+	get_can_id(&cf.can_id, idstr, 16);
+
+	ptr = buf + n; /* start of ASCII hex frame data */
+
+	cf.len = dlen;
+
+	for (i = 0; i < dlen; i++) {
+		ctmp = asc2nibble(ptr[0]);
+		if (ctmp > 0x0F)
+			return;
+
+		cf.data[i] = (ctmp << 4);
+
+		ctmp = asc2nibble(ptr[1]);
+		if (ctmp > 0x0F)
+			return;
+
+		cf.data[i] |= ctmp;
+
+		ptr += 3; /* start of next ASCII hex byte */
+	}
+
+	/* skip FCRC to get Flags value */
+	if (sscanf(ptr, "%*x %x ", &flags) != 1)
+		return;
+
+	if (flags & ASC_F_RTR) {
+		cf.can_id |= CAN_RTR_FLAG;
+		/* dlen is always 0 for classic CAN RTR frames
+		   but the DLC value is valid in RTR cases */
+		cf.len = dlc;
+		/* sanitize payload length value */
+		if (dlc > CAN_MAX_DLEN)
+			cf.len = CAN_MAX_DLEN;
+	}
+
+	/* check for extra DLC when having a Classic CAN with 8 bytes payload */
+	if ((cf.len == CAN_MAX_DLEN) && (dlc > CAN_MAX_DLEN) && (dlc <= CAN_MAX_RAW_DLC))
+		cf.len8_dlc = dlc;
+
+	calc_tv(&tv, &read_tv, date_tvp, timestamps, dplace);
+	prframe(outfile, &tv, interface, (cu_t *)&cf, dir[0]);
+	fflush(outfile);
+}
+
+static void eval_canxl_fd(char* buf, struct timeval *date_tvp, char timestamps,
+			  int dplace, int disable_dir, FILE *outfile)
+{
+	int interface;
+	static struct timeval tv; /* current frame timestamp */
+	static struct timeval read_tv; /* frame timestamp from ASC file */
+	struct canfd_frame cf = { 0 };
+	unsigned char ctmp;
+	unsigned int flags;
+	int dlc, dlen = 0;
+	char idstr[21];
+	char dir[5]; /* 'Rx'/'Tx'/'TxRq' plus terminating zero */
+	char *ptr;
+	int i;
+	int n = 0; /* sscanf consumed characters */
+	unsigned long long sec, usec;
+
+	/*
+	 * 59.171614 CANXL   2 Rx   FBFF   243215   176      432  msgCanFDTest2 \
+	 * 9 12 e1 89 e8 c2 b9 6d 5a f1 11 22 33 44 a 12345 00001240 00000000 \
+	 * 000000050005000e 0000000000a00010 0000000a000a001d		\
+	 * 0000000000a00002 000000100010000f 000000000a00001
+	 */
+
+	/* check for valid line without symbolic name */
+	if (sscanf(buf,
+		   "%llu.%llu %*s %d %4s " /* time, CANXL, channel, direction */
+		   "%*s %*s %*s %20s " /* frame format, msg dur, bit count, ID */
+		   "%x %d %n", /* DLC, Datalen */
+		   &sec, &usec, &interface, dir,
+		   idstr,
+		   &dlc, &dlen, &n) != 7) {
+		/* check for valid line with a symbolic name */
+		if (sscanf(buf,
+			   "%llu.%llu %*s %d %4s " /* time, CANXL, channel, direction */
+			   "%*s %*s %*s %20s " /* frame format, msg dur, bit count, ID */
+			   "%*s %x %d %n", /* sym name, DLC, Datalen */
+			   &sec, &usec, &interface, dir,
+			   idstr,
+			   &dlc, &dlen, &n) != 7) {
+			/* no valid CAN CC format pattern */
+			return;
+		}
+	}
+
+	read_tv.tv_sec = sec;
+	read_tv.tv_usec = usec;
+
+	/* check for allowed (unsigned) value ranges */
+	if ((dlen > CANFD_MAX_DLEN) || (dlc > CANFD_MAX_DLC))
+		return;
+
+	if (strlen(dir) != 2) /* "Rx" or "Tx" */
+		return;
+
+	if (disable_dir)
+		dir[0] = NO_DIR;
+
+	/* check for signed integer overflow */
+	if (dplace == 4 && read_tv.tv_usec >= INT_MAX / 100)
+		return;
+
+	/* check for signed integer overflow */
+	if (dplace == 5 && read_tv.tv_usec >= INT_MAX / 10)
+		return;
+
+	get_can_id(&cf.can_id, idstr, 16);
+
+	ptr = buf + n; /* start of ASCII hex frame data */
+
+	cf.len = dlen;
+
+	for (i = 0; i < dlen; i++) {
+		ctmp = asc2nibble(ptr[0]);
+		if (ctmp > 0x0F)
+			return;
+
+		cf.data[i] = (ctmp << 4);
+
+		ctmp = asc2nibble(ptr[1]);
+		if (ctmp > 0x0F)
+			return;
+
+		cf.data[i] |= ctmp;
+
+		ptr += 3; /* start of next ASCII hex byte */
+	}
+
+	/* skip stuff field and FCRC to get Flags value */
+	if (sscanf(ptr, "%*s %*s %x ", &flags) != 1)
+		return;
+
+	if (!(flags & ASC_F_FDF))
+	    return;
+
+	cf.flags = CANFD_FDF;
+
+	if (flags & ASC_F_BRS)
+		cf.flags |= CANFD_BRS;
+	if (flags & ASC_F_ESI)
+		cf.flags |= CANFD_ESI;
+
+	calc_tv(&tv, &read_tv, date_tvp, timestamps, dplace);
+	prframe(outfile, &tv, interface, (cu_t *)&cf, dir[0]);
+	fflush(outfile);
+}
+
+static void eval_canxl_xl(char* buf, struct timeval *date_tvp, char timestamps,
+			  int dplace, int disable_dir, FILE *outfile)
+{
+	int interface;
+	static struct timeval tv; /* current frame timestamp */
+	static struct timeval read_tv; /* frame timestamp from ASC file */
+	struct canxl_frame cf = { 0 };
+	unsigned char sdt, vcid, secbit, ctmp;
+	unsigned int af, flags;
+	int dlc, dlen = 0;
+	char idstr[21];
+	char dir[5]; /* 'Rx'/'Tx'/'TxRq' plus terminating zero */
+	char *ptr;
+	int i;
+	int n = 0; /* sscanf consumed characters */
+	unsigned long long sec, usec;
+
+	/*
+	 * 59.171614 CANXL   2 Rx   XLFF   984438   4656      432  msgCanXlTest1 \
+	 * e0 0  1fe  511 1 1f96 00 00000000 e1 89 e8 c2 b9 6d 5a f1 c5 97 ( .. ) \
+	 * ( .. ) c7 e3 4e f6 bf 12cfbd62 02503000 00000000 000000050005000e \
+	 * 0000000000a00010 0000000a000a001d 0000000000a00002 000000100010000f \
+	 * 000000000a00001
+	 */
+
+	/* check for valid line without symbolic name */
+	if (sscanf(buf,
+		   "%llu.%llu %*s %d %4s " /* time, CANXL, channel, direction */
+		   "%*s %*s %*s %20s " /* frame format, msg dur, bit count, ID */
+		   "%hhx %hhx %x %d " /* SDT, SEC, DLC, Datalen */
+		   "%*s %*s %hhx %x %n", /* stuff bit count, crc, VCID, AF */
+		   &sec, &usec, &interface, dir,
+		   idstr,
+		   &sdt, &secbit, &dlc, &dlen,
+		   &vcid, &af, &n) != 11) {
+		/* check for valid line with a symbolic name */
+		if (sscanf(buf,
+			   "%llu.%llu %*s %d %4s " /* time, CANXL, channel, direction */
+			   "%*s %*s %*s %20s " /* frame format, msg dur, bit count, ID */
+			   "%*s %hhx %hhx %x %d " /* sym name, SDT, SEC, DLC, Datalen */
+			   "%*s %*s %hhx %x %n", /* stuff bit count, crc, VCID, AF */
+			   &sec, &usec, &interface, dir,
+			   idstr,
+			   &sdt, &secbit, &dlc, &dlen,
+			   &vcid, &af, &n) != 11) {
+
+			/* no valid CANXL format pattern */
+			return;
+		}
+	}
+
+	read_tv.tv_sec = sec;
+	read_tv.tv_usec = usec;
+
+	/* check for allowed (unsigned) value ranges */
+	if ((dlen > CANXL_MAX_DLEN) || (dlc > CANXL_MAX_DLC) || (secbit > 1))
+		return;
+
+	cf.sdt = sdt;
+	cf.af = af;
+
+	if (strlen(dir) != 2) /* "Rx" or "Tx" */
+		return;
+
+	if (disable_dir)
+		dir[0] = NO_DIR;
+
+	/* check for signed integer overflow */
+	if (dplace == 4 && read_tv.tv_usec >= INT_MAX / 100)
+		return;
+
+	/* check for signed integer overflow */
+	if (dplace == 5 && read_tv.tv_usec >= INT_MAX / 10)
+		return;
+
+	/* don't trust ASCII content - sanitize data length */
+	if (dlen != dlc + 1)
+		return;
+
+	get_can_id(&cf.prio, idstr, 16);
+
+	if ((cf.prio & CANXL_PRIO_MASK) != cf.prio)
+		return;
+
+	if (vcid)
+		cf.prio |= (vcid << CANXL_VCID_OFFSET);
+
+	ptr = buf + n; /* start of ASCII hex frame data */
+
+	cf.len = dlen;
+
+	for (i = 0; i < dlen; i++) {
+		ctmp = asc2nibble(ptr[0]);
+		if (ctmp > 0x0F)
+			return;
+
+		cf.data[i] = (ctmp << 4);
+
+		ctmp = asc2nibble(ptr[1]);
+		if (ctmp > 0x0F)
+			return;
+
+		cf.data[i] |= ctmp;
+
+		ptr += 3; /* start of next ASCII hex byte */
+	}
+
+	/* skip FCRC to get Flags value */
+	if (sscanf(ptr, "%*x %x ", &flags) != 1)
+		return;
+
+	/* mandatory for CAN XL frames */
+	if (!(flags & ASC_F_XLF))
+		return;
+
+	/* mark as CAN XL */
+	cf.flags = CANXL_XLF;
+
+	if (flags & ASC_F_SEC)
+		cf.flags |= CANXL_SEC;
+
+	if (flags & ASC_F_RES)
+		cf.flags |= CANXL_RRS;
+
+	calc_tv(&tv, &read_tv, date_tvp, timestamps, dplace);
+	prframe(outfile, &tv, interface, (cu_t *)&cf, dir[0]);
+	fflush(outfile);
+
+	/* No support for CAN XL ErrorFrames */
+}
+
+static void eval_canxl(char* buf, struct timeval *date_tvp, char timestamps,
+		       int dplace, int disable_dir, FILE *outfile)
+{
+	int interface;
+	char dir[5]; /* 'Rx'/'Tx'/'TxRq' plus terminating zero */
+	char frfo[5]; /* frame format 'CBFF'/'CEFF'/'FBFF'/'FEFF'/'XLFF' plus terminating zero */
+	unsigned long long sec, usec;
+
+	/*
+	 * The CANXL format is mainly in hex representation but <DataLength>
+	 * and probably some content we skip anyway. Check out the new spec:
+	 * CAN, Log & Trigger ASC Logging Format Spec V 1.4.17 of 2024-05-21
+	 */
+
+	/*
+	 * This is a CAN XL ("XLFF") example for the CANXL Message Event:
+	 *
+	 * 59.171614 CANXL   2 Rx   XLFF   984438   4656      432  msgCanXlTest1 \
+	 * e0 0  1fe  511 1 1f96 00 00000000 e1 89 e8 c2 b9 6d 5a f1 c5 97 ( .. ) \
+	 * ( .. ) c7 e3 4e f6 bf 12cfbd62 02503000 00000000 000000050005000e \
+	 * 0000000000a00010 0000000a000a001d 0000000000a00002 000000100010000f \
+	 * 000000000a00001
+	 */
+
+	/* check for valid line until frame format tag */
+	if (sscanf(buf, "%llu.%llu %*s %d %4s %4s ",
+		   &sec, &usec, &interface, dir, frfo) != 5)
+		return; /* no valid CANXL format pattern */
+
+	if (strlen(dir) != 2) /* "Rx" or "Tx" */
+		return;
+
+	if (strlen(frfo) != 4) /* 'CBFF'/'CEFF'/'FBFF'/'FEFF'/'XLFF' */
+		return;
+
+	if (!strncmp(frfo, "XLFF", 4))
+		eval_canxl_xl(buf, date_tvp, timestamps, dplace, disable_dir, outfile);
+	else if (!strncmp(frfo, "FBFF", 4))
+		eval_canxl_fd(buf, date_tvp, timestamps, dplace, disable_dir, outfile);
+	else if (!strncmp(frfo, "FEFF", 4))
+		eval_canxl_fd(buf, date_tvp, timestamps, dplace, disable_dir, outfile);
+	else if (!strncmp(frfo, "CBFF", 4))
+		eval_canxl_cc(buf, date_tvp, timestamps, dplace, disable_dir, outfile);
+	else if (!strncmp(frfo, "CEFF", 4))
+		eval_canxl_cc(buf, date_tvp, timestamps, dplace, disable_dir, outfile);
+}
+
 static int get_date(struct timeval *tv, char *date)
 {
 	struct tm tms;
 	unsigned int msecs = 0;

-	if (strcasestr(date, " pm ") != NULL) {
+	if ((strcasestr(date, " am ") != NULL) || (strcasestr(date, " pm ") != NULL)) {
 		/* assume EN/US date due to existing am/pm field */

 		if (!setlocale(LC_TIME, "en_US")) {
@ -393,9 +790,11 @@ static int get_date(struct timeval *tv, char *date)
 		}

 		if (!strptime(date, "%B %d %I:%M:%S %p %Y", &tms)) {
-			/* The string might contain a milliseconds value which strptime()
-			   does not support. So we read the ms value into the year variable
-			   before parsing the real year value (hack) */
+			/*
+			 * The string might contain a milliseconds value which strptime()
+			 * does not support. So we read the ms value into the year variable
+			 * before parsing the real year value (hack)
+			 */
 			if (!strptime(date, "%B %d %I:%M:%S.%Y %p %Y", &tms))
 				return 1;
 			sscanf(date, "%*s %*d %*d:%*d:%*d.%3u ", &msecs);
@ -410,9 +809,11 @@ static int get_date(struct timeval *tv, char *date)
 		}

 		if (!strptime(date, "%B %d %H:%M:%S %Y", &tms)) {
-			/* The string might contain a milliseconds value which strptime()
-			   does not support. So we read the ms value into the year variable
-			   before parsing the real year value (hack) */
+			/*
+			 * The string might contain a milliseconds value which strptime()
+			 * does not support. So we read the ms value into the year variable
+			 * before parsing the real year value (hack)
+			 */
 			if (!strptime(date, "%B %d %H:%M:%S.%Y %Y", &tms))
 				return 1;
 			sscanf(date, "%*s %*d %*d:%*d:%*d.%3u ", &msecs);
@ -434,11 +835,11 @@ static int get_date(struct timeval *tv, char *date)

 int main(int argc, char **argv)
 {
-	char buf[BUFLEN], tmp1[BUFLEN], tmp2[BUFLEN];
+	char buf[BUFLEN], tmp1[10], tmp2[10];

 	FILE *infile = stdin;
 	FILE *outfile = stdout;
-	static int verbose;
+	static int verbose, disable_dir;
 	static struct timeval date_tv; /* date of the ASC file */
 	static int dplace; /* decimal place 4, 5 or 6 or uninitialized */
 	static char base; /* 'd'ec or 'h'ex */
@ -446,7 +847,7 @@ int main(int argc, char **argv)
 	int opt;
 	unsigned long long sec, usec;

-	while ((opt = getopt(argc, argv, "I:O:v?")) != -1) {
+	while ((opt = getopt(argc, argv, "I:O:dv?")) != -1) {
 		switch (opt) {
 		case 'I':
 			infile = fopen(optarg, "r");
@ -464,6 +865,10 @@ int main(int argc, char **argv)
 			}
 			break;

+		case 'd':
+			disable_dir = 1;
+			break;
+
 		case 'v':
 			verbose = 1;
 			break;
@ -488,7 +893,7 @@ int main(int argc, char **argv)

 			/* check for base and timestamp entries in the header */
 			if ((!base) &&
-			    (sscanf(buf, "base %s timestamps %s", tmp1, tmp2) == 2)) {
+			    (sscanf(buf, "base %9s timestamps %9s", tmp1, tmp2) == 2)) {
 				base = tmp1[0];
 				timestamps = tmp2[0];
 				if (verbose)
@ -522,7 +927,7 @@ int main(int argc, char **argv)
 			}

 			/* check for decimal places length in valid CAN frames */
-			if (sscanf(buf, "%llu.%s %s ", &sec, tmp2,
+			if (sscanf(buf, "%llu.%9s %9s ", &sec, tmp2,
 				   tmp1) != 3)
 				continue; /* dplace remains zero until first found CAN frame */

@ -537,15 +942,19 @@ int main(int argc, char **argv)
 			}
 		}

-		/* the representation of a valid CAN frame is known here */
-		/* so try to get CAN frames and ErrorFrames and convert them */
+		/*
+		 * The representation of a valid CAN frame is known here.
+		 * So try to get CAN frames and ErrorFrames and convert them.
+		 */

-		/* check classic CAN format or the CANFD tag which can take both types */
-		if (sscanf(buf, "%llu.%llu %s ", &sec,  &usec, tmp1) == 3){
-			if (!strncmp(tmp1, "CANFD", 5))
-				eval_canfd(buf, &date_tv, timestamps, dplace, outfile);
+		/* check classic CAN format or the CANFD/CANXL tag which can take different types */
+		if (sscanf(buf, "%llu.%llu %9s ", &sec,  &usec, tmp1) == 3) {
+			if (!strncmp(tmp1, "CANXL", 5))
+				eval_canxl(buf, &date_tv, timestamps, dplace, disable_dir, outfile);
+			else if (!strncmp(tmp1, "CANFD", 5))
+				eval_canfd(buf, &date_tv, timestamps, dplace, disable_dir, outfile);
 			else
-				eval_can(buf, &date_tv, timestamps, base, dplace, outfile);
+				eval_can(buf, &date_tv, timestamps, base, dplace, disable_dir, outfile);
 		}
 	}
 	fclose(outfile);
--- a/canbusload.c
+++ b/canbusload.c
@ -45,14 +45,17 @@
 #include <ctype.h>
 #include <libgen.h>
 #include <signal.h>
+#include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <termios.h>
 #include <time.h>
 #include <unistd.h>

 #include <net/if.h>
 #include <sys/ioctl.h>
+#include <sys/param.h>
 #include <sys/socket.h>
 #include <sys/time.h>
 #include <sys/types.h>
@ -65,34 +68,69 @@
 #include "terminal.h"
 #include "canframelen.h"

-#define MAXSOCK 16    /* max. number of CAN interfaces given on the cmdline */
+#define ANYDEV "any" /* name of interface to receive from any CAN interface */
+#define MAXDEVS 20   /* max. number of CAN interfaces given on the cmdline */

 #define PERCENTRES 5 /* resolution in percent for bargraph */
 #define NUMBAR (100 / PERCENTRES) /* number of bargraph elements */
+#define BRSTRLEN 20
+#define VISUAL_WINDOW 90 /* window width for visualization */
+
+/*
+ * Inspired from
+ * https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/
+ * include/linux/sched/loadavg.h
+ *
+ * Following are the fixed-point math constants and the exponential-damping
+ * factors for:
+ *  - 1 samples/s in 1 minute
+ *  - 1 samples/s in 5 minutes
+ *  - 1 samples/s in 15 minutes
+ * in fixed-point representation.
+ */
+#define FP_SHIFT 12              /* bits of precision */
+#define FP_ONE   (1 << FP_SHIFT) /* 1.0 fixed-point representation */
+#define EXP_1    4028            /* (1 / e ^ (1 /  60)) * FP_ONE */
+#define EXP_5    4082            /* (1 / e ^ (1 / 300)) * FP_ONE */
+#define EXP_15   4091            /* (1 / e ^ (1 / 900)) * FP_ONE */

 extern int optind, opterr, optopt;

 static struct {
 	char devname[IFNAMSIZ + 1];
+	char bitratestr[BRSTRLEN]; /* 100000/2000000 => 100k/2M */
+	char recv_direction;
+	int ifindex;
 	unsigned int bitrate;
 	unsigned int dbitrate;
 	unsigned int recv_frames;
 	unsigned int recv_bits_total;
 	unsigned int recv_bits_payload;
 	unsigned int recv_bits_dbitrate;
-} stat[MAXSOCK + 1];
+	unsigned int load_min;
+	unsigned int load_max;
+	unsigned int load_1m;
+	unsigned int load_5m;
+	unsigned int load_15m;
+	unsigned int loads[VISUAL_WINDOW];
+	unsigned int index;
+} stat[MAXDEVS + 1];

 static volatile int running = 1;
 static volatile sig_atomic_t signal_num;
 static int max_devname_len; /* to prevent frazzled device name output */
-static int max_bitrate_len;
-static int currmax;
+static int max_bitratestr_len;
+static unsigned int currmax;
 static unsigned char redraw;
 static unsigned char timestamp;
 static unsigned char color;
 static unsigned char bargraph;
+static bool statistic;
+static bool reset;
+static bool visualize;
 static enum cfl_mode mode = CFL_WORSTCASE;
 static char *prg;
+static struct termios old;

 static void print_usage(char *prg)
 {
@ -106,21 +144,23 @@ static void print_usage(char *prg)
 	fprintf(stderr, "         -r  (redraw the terminal - similar to top)\n");
 	fprintf(stderr, "         -i  (ignore bitstuffing in bandwidth calculation)\n");
 	fprintf(stderr, "         -e  (exact calculation of stuffed bits)\n");
+	fprintf(stderr, "         -s  (show statistics, press 'r' to reset)\n");
+	fprintf(stderr, "         -v  (show busload visualization)\n");
 	fprintf(stderr, "\n");
-	fprintf(stderr, "Up to %d CAN interfaces with mandatory bitrate can be specified on the \n", MAXSOCK);
-	fprintf(stderr, "commandline in the form: <ifname>@<bitrate>[,<dbitrate>]\n\n");
+	fprintf(stderr, "Up to %d CAN interfaces with mandatory bitrate can be specified on the \n", MAXDEVS);
+	fprintf(stderr, "commandline in the form: <ifname>@<bitrate>[,<dbitrate>]\n");
+	fprintf(stderr, "The interface name 'any' enables an auto detection with the given bitrate[s]\n\n");
 	fprintf(stderr, "The bitrate is mandatory as it is needed to know the CAN bus bitrate to\n");
 	fprintf(stderr, "calculate the bus load percentage based on the received CAN frames.\n");
 	fprintf(stderr, "Due to the bitstuffing estimation the calculated busload may exceed 100%%.\n");
 	fprintf(stderr, "For each given interface the data is presented in one line which contains:\n\n");
-	fprintf(stderr, "(interface) (received CAN frames) (used bits total) (used bits for payload)\n");
+	fprintf(stderr, "(interface) (received CAN frames) (bits total) (bits payload) (bits payload brs)\n");
 	fprintf(stderr, "\nExamples:\n");
-	fprintf(stderr, "\nuser$> canbusload can0@100000 can1@500000 can2@500000 can3@500000 -r -t -b -c\n\n");
-	fprintf(stderr, "%s 2014-02-01 21:13:16 (worst case bitstuffing)\n", prg);
-	fprintf(stderr, " can0@100000   805   74491  36656  74%% |XXXXXXXXXXXXXX......|\n");
-	fprintf(stderr, " can1@500000   796   75140  37728  15%% |XXX.................|\n");
-	fprintf(stderr, " can2@500000     0       0      0   0%% |....................|\n");
-	fprintf(stderr, " can3@500000    47    4633   2424   0%% |....................|\n");
+	fprintf(stderr, "\nuser$> canbusload can0@100000 can1@500000,2000000 can2@500000 -r -t -b -c\n\n");
+	fprintf(stderr, "%s 2024-08-08 16:30:05 (worst case bitstuffing)\n", prg);
+	fprintf(stderr, " can0@100k      192   21980    9136       0  21%% |TTTT................|\n");
+	fprintf(stderr, " can1@500k/2M  2651  475500  234448  131825  74%% |XXXXXXXXXXXXXX......|\n");
+	fprintf(stderr, " can2@500k      855  136777   62968   35219  27%% |RRRRR...............|\n");
 	fprintf(stderr, "\n");
 }

@ -130,9 +170,45 @@ static void sigterm(int signo)
 	signal_num = signo;
 }

+static int add_bitrate(char *brstr, unsigned int bitrate)
+{
+	if (bitrate % 1000000 == 0)
+		return sprintf(brstr, "%dM", bitrate / 1000000);
+
+	if (bitrate % 1000 == 0)
+		return sprintf(brstr, "%dk", bitrate / 1000);
+
+	return sprintf(brstr, "%d", bitrate);
+}
+
+static void create_bitrate_string(int stat_idx, int *max_bitratestr_len)
+{
+	int ptr;
+
+	ptr = add_bitrate(&stat[stat_idx].bitratestr[0], stat[stat_idx].bitrate);
+
+	if (stat[stat_idx].bitrate != stat[stat_idx].dbitrate) {
+		ptr += sprintf(&stat[stat_idx].bitratestr[ptr], "/");
+		ptr += add_bitrate(&stat[stat_idx].bitratestr[ptr], stat[stat_idx].dbitrate);
+	}
+
+	if (ptr > *max_bitratestr_len)
+		*max_bitratestr_len = ptr;
+}
+
+static unsigned int calc_load(unsigned int load_fp,
+                              unsigned int exp_fp,
+                              unsigned int sample)
+{
+	unsigned int sample_fp  = sample << FP_SHIFT;
+	unsigned int damped_sum = (load_fp * exp_fp) +
+	                          (sample_fp * (FP_ONE - exp_fp));
+	return damped_sum >> FP_SHIFT;
+}
+
 static void printstats(int signo)
 {
-	int i, j, percent;
+	unsigned int i, j, k, percent, index;

 	if (redraw)
 		printf("%s", CSR_HOME);
@ -194,15 +270,39 @@ static void printstats(int signo)
 		else
 			percent = 0;

-		printf(" %*s@%-*d %5d %7d %6d %6d %3d%%",
+		printf(" %*s@%-*s %5d %7d %7d %7d %3d%%",
 		       max_devname_len, stat[i].devname,
-		       max_bitrate_len, stat[i].bitrate,
+		       max_bitratestr_len, stat[i].bitratestr,
 		       stat[i].recv_frames,
 		       stat[i].recv_bits_total,
 		       stat[i].recv_bits_payload,
 		       stat[i].recv_bits_dbitrate,
 		       percent);

+		if (statistic) {
+			if (reset) {
+				stat[i].load_min = UINT_MAX;
+				stat[i].load_max = 0;
+				stat[i].load_1m = 0;
+				stat[i].load_5m = 0;
+				stat[i].load_15m = 0;
+			}
+
+			stat[i].load_min = MIN(stat[i].load_min, percent);
+			stat[i].load_max = MAX(stat[i].load_max, percent);
+
+			stat[i].load_1m = calc_load(stat[i].load_1m, EXP_1, percent);
+			stat[i].load_5m = calc_load(stat[i].load_5m, EXP_5, percent);
+			stat[i].load_15m = calc_load(stat[i].load_15m, EXP_15, percent);
+
+			printf(" min:%3d%%, max:%3d%%, load:%3d%% %3d%% %3d%%",
+			       stat[i].load_min,
+			       stat[i].load_max,
+			       (stat[i].load_1m + (FP_ONE >> 1)) >> FP_SHIFT,
+			       (stat[i].load_5m + (FP_ONE >> 1)) >> FP_SHIFT,
+			       (stat[i].load_15m + (FP_ONE >> 1)) >> FP_SHIFT);
+		}
+
 		if (bargraph) {

 			printf(" |");
@ -212,7 +312,7 @@ static void printstats(int signo)

 			for (j = 0; j < NUMBAR; j++) {
 				if (j < percent / PERCENTRES)
-					printf("X");
+					printf("%c", stat[i].recv_direction);
 				else
 					printf(".");
 			}
@ -220,6 +320,28 @@ static void printstats(int signo)
 			printf("|");
 		}

+		if (visualize) {
+			stat[i].loads[stat[i].index] = percent;
+			stat[i].index = (stat[i].index + 1) % VISUAL_WINDOW;
+
+			printf("\n");
+			for (j = 0; j < NUMBAR; j++) {
+				printf("%3d%%|", (NUMBAR - j) * PERCENTRES);
+				index = stat[i].index;
+				for (k = 0; k < VISUAL_WINDOW; k++) {
+					percent = stat[i].loads[index];
+
+					if ((percent / PERCENTRES) >= (NUMBAR - j))
+						printf("X");
+					else
+						printf(".");
+
+					index = (index + 1) % VISUAL_WINDOW;
+				}
+				printf("\n");
+			}
+		}
+
 		if (color)
 			printf("%s", ATTRESET);

@ -230,8 +352,11 @@ static void printstats(int signo)
 		stat[i].recv_bits_total = 0;
 		stat[i].recv_bits_dbitrate = 0;
 		stat[i].recv_bits_payload = 0;
+		stat[i].recv_direction = '.';
 	}

+	reset = false;
+
 	if (!redraw)
 		printf("\n");

@ -240,17 +365,35 @@ static void printstats(int signo)
 	alarm(1);
 }

+void cleanup()
+{
+	tcsetattr(STDIN_FILENO, TCSANOW, &old);
+}
+
 int main(int argc, char **argv)
 {
 	fd_set rdfs;
-	int s[MAXSOCK];
-
+	int s;
 	int opt;
 	char *ptr, *nptr;
 	struct sockaddr_can addr;
 	struct canfd_frame frame;
-	int nbytes, i;
-	struct ifreq ifr;
+	struct iovec iov;
+	struct msghdr msg;
+	unsigned int i;
+	int nbytes;
+
+	int have_anydev = 0;
+	unsigned int anydev_bitrate = 0;
+	unsigned int anydev_dbitrate = 0;
+	char anydev_bitratestr[BRSTRLEN]; /* 100000/2000000 => 100k/2M */
+	struct termios temp;
+
+	tcgetattr(STDIN_FILENO, &old);
+	atexit(cleanup);
+	temp = old;
+	temp.c_lflag &= ~(ICANON | ECHO);
+	tcsetattr(STDIN_FILENO, TCSANOW, &temp);

 	signal(SIGTERM, sigterm);
 	signal(SIGHUP, sigterm);
@ -260,7 +403,7 @@ int main(int argc, char **argv)

 	prg = basename(argv[0]);

-	while ((opt = getopt(argc, argv, "rtbcieh?")) != -1) {
+	while ((opt = getopt(argc, argv, "rtbciesvh?")) != -1) {
 		switch (opt) {
 		case 'r':
 			redraw = 1;
@ -286,6 +429,15 @@ int main(int argc, char **argv)
 			mode = CFL_EXACT;
 			break;

+		case 's':
+			statistic = true;
+			reset = true;
+			break;
+
+		case 'v':
+			visualize = true;
+			break;
+
 		default:
 			print_usage(prg);
 			exit(1);
@ -300,27 +452,22 @@ int main(int argc, char **argv)

 	currmax = argc - optind; /* find real number of CAN devices */

-	if (currmax > MAXSOCK) {
-		printf("More than %d CAN devices given on commandline!\n", MAXSOCK);
+	if (currmax > MAXDEVS) {
+		printf("More than %d CAN devices given on commandline!\n", MAXDEVS);
 		return 1;
 	}

+	/* prefill stat[] array with given interface assignments */
 	for (i = 0; i < currmax; i++) {
-		ptr = argv[optind + i];
+		ptr = argv[optind + i + have_anydev];

 		nbytes = strlen(ptr);
-		if (nbytes >= (int)(IFNAMSIZ + sizeof("@1000000") + 1)) {
+		if (nbytes >= (int)(IFNAMSIZ + sizeof("@1000000,2000000") + 1)) {
 			printf("name of CAN device '%s' is too long!\n", ptr);
 			return 1;
 		}

-		pr_debug("open %d '%s'.\n", i, ptr);
-
-		s[i] = socket(PF_CAN, SOCK_RAW, CAN_RAW);
-		if (s[i] < 0) {
-			perror("socket");
-			return 1;
-		}
+		pr_debug("handle %d '%s'.\n", i, ptr);

 		nptr = strchr(ptr, '@');

@ -330,87 +477,168 @@ int main(int argc, char **argv)
 			return 1;
 		}

+		/* interface name length */
 		nbytes = nptr - ptr;  /* interface name is up the first '@' */
-
 		if (nbytes >= (int)IFNAMSIZ) {
 			printf("name of CAN device '%s' is too long!\n", ptr);
 			return 1;
 		}

+		/* copy interface name to stat[] entry */
 		strncpy(stat[i].devname, ptr, nbytes);
-		memset(&ifr.ifr_name, 0, sizeof(ifr.ifr_name));
-		strncpy(ifr.ifr_name, ptr, nbytes);

 		if (nbytes > max_devname_len)
 			max_devname_len = nbytes; /* for nice printing */

 		char *endp;
-		stat[i].bitrate = strtol(nptr + 1, &endp, 0); /* bitrate is placed behind the '@' */
+		 /* bitrate is placed behind the '@' */
+		stat[i].bitrate = strtol(nptr + 1, &endp, 0);
+
+		/* check for CAN FD additional data bitrate */
 		if (*endp == ',')
 			/* data bitrate is placed behind the ',' */
 			stat[i].dbitrate = strtol(endp + 1, &endp, 0);
 		else
 			stat[i].dbitrate = stat[i].bitrate;

-		if (!stat[i].bitrate || stat[i].bitrate > 1000000) {
+		if (!stat[i].bitrate || stat[i].bitrate > 1000000 ||
+		    !stat[i].dbitrate || stat[i].dbitrate > 8000000) {
 			printf("invalid bitrate for CAN device '%s'!\n", ptr);
 			return 1;
 		}

-		nbytes = strlen(nptr + 1);
-		if (nbytes > max_bitrate_len)
-			max_bitrate_len = nbytes; /* for nice printing */
+		/* prepare bitrate string for hot path */
+		create_bitrate_string(i, &max_bitratestr_len);

-		pr_debug("using interface name '%s'.\n", ifr.ifr_name);
+		stat[i].recv_direction = '.';
+
+		/* handling for 'any' device */
+		if (have_anydev == 0 && strcmp(ANYDEV, stat[i].devname) == 0) {
+			anydev_bitrate = stat[i].bitrate;
+			anydev_dbitrate = stat[i].dbitrate;
+			memcpy(anydev_bitratestr, stat[i].bitratestr, BRSTRLEN);
+			/* no real interface: remove this command line entry */
+			have_anydev = 1;
+			currmax--;
+			i--;
+		} else {
+			stat[i].ifindex = if_nametoindex(stat[i].devname);
+			if (!stat[i].ifindex) {
+				printf("invalid CAN device '%s'!\n", stat[i].devname);
+				return 1;
+			}
+			pr_debug("using interface name '%s'.\n", stat[i].devname);
+		}
+	}
+
+	s = socket(PF_CAN, SOCK_RAW, CAN_RAW);
+	if (s < 0) {
+		perror("socket");
+		return 1;
+	}

 	/* try to switch the socket into CAN FD mode */
 	const int canfd_on = 1;
-		setsockopt(s[i], SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &canfd_on, sizeof(canfd_on));
-
-		if (ioctl(s[i], SIOCGIFINDEX, &ifr) < 0) {
-			perror("SIOCGIFINDEX");
-			exit(1);
-		}
+	setsockopt(s, SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &canfd_on, sizeof(canfd_on));

 	addr.can_family = AF_CAN;
-		addr.can_ifindex = ifr.ifr_ifindex;
+	addr.can_ifindex = 0; /* any CAN device */

-		if (bind(s[i], (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+	if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
 		perror("bind");
 		return 1;
 	}
-	}

 	alarm(1);

 	if (redraw)
 		printf("%s", CLR_SCREEN);

+	/* these settings are static and can be held out of the hot path */
+	iov.iov_base = &frame;
+	msg.msg_name = &addr;
+	msg.msg_iov = &iov;
+	msg.msg_iovlen = 1;
+	msg.msg_control = NULL;
+
 	while (running) {
 		FD_ZERO(&rdfs);
-		for (i = 0; i < currmax; i++)
-			FD_SET(s[i], &rdfs);
+		FD_SET(s, &rdfs);
+		FD_SET(STDIN_FILENO, &rdfs);

-		if (select(s[currmax - 1] + 1, &rdfs, NULL, NULL, NULL) < 0) {
+		if (select(s + 1, &rdfs, NULL, NULL, NULL) < 0) {
 			//perror("pselect");
 			continue;
 		}

-		for (i = 0; i < currmax; i++) { /* check all CAN RAW sockets */
+		if (FD_ISSET(STDIN_FILENO, &rdfs)) {
+			if (getchar() == 'r') {
+				reset = true;
+			}
+		}

-			if (FD_ISSET(s[i], &rdfs)) {
-				nbytes = read(s[i], &frame, sizeof(frame));
+		/* these settings may be modified by recvmsg() */
+		iov.iov_len = sizeof(frame);
+		msg.msg_namelen = sizeof(addr);
+		msg.msg_controllen = 0;
+		msg.msg_flags = 0;
+
+		nbytes = recvmsg(s, &msg, 0);

 		if (nbytes < 0) {
 			perror("read");
 			return 1;
 		}

-				if (nbytes < (int)sizeof(struct can_frame)) {
+		if (nbytes != (int)sizeof(struct can_frame) &&
+		    nbytes != (int)sizeof(struct canfd_frame)) {
 			fprintf(stderr, "read: incomplete CAN frame\n");
 			return 1;
 		}

+		/* find received ifindex in stat[] array */
+		for (i = 0; i < currmax; i++) {
+			if (stat[i].ifindex == addr.can_ifindex)
+				break;
+		}
+
+		/* not found? check for unknown interface */
+		if (i >= currmax) {
+			/* drop unwanted traffic */
+			if (have_anydev == 0)
+				continue;
+
+			/* can we add another interface? */
+			if (currmax >= MAXDEVS)
+				continue;
+
+			/* add an new entry */
+			stat[i].ifindex = addr.can_ifindex;
+			stat[i].bitrate = anydev_bitrate;
+			stat[i].dbitrate = anydev_dbitrate;
+			memcpy(stat[i].bitratestr, anydev_bitratestr, BRSTRLEN);
+			stat[i].recv_direction = '.';
+			if_indextoname(addr.can_ifindex, stat[i].devname);
+			nbytes = strlen(stat[i].devname);
+			if (nbytes > max_devname_len)
+				max_devname_len = nbytes; /* for nice printing */
+			currmax++;
+		}
+
+		if (msg.msg_flags & MSG_DONTROUTE) {
+			/* TX direction */
+			if (stat[i].recv_direction == '.')
+				stat[i].recv_direction = 'T';
+			else if (stat[i].recv_direction == 'R')
+				stat[i].recv_direction = 'X';
+		} else {
+			/* RX direction */
+			if (stat[i].recv_direction == '.')
+				stat[i].recv_direction = 'R';
+			else if (stat[i].recv_direction == 'T')
+				stat[i].recv_direction = 'X';
+		}
+
 		stat[i].recv_frames++;
 		stat[i].recv_bits_payload += frame.len * 8;
 		stat[i].recv_bits_dbitrate += can_frame_dbitrate_length(
@ -418,11 +646,8 @@ int main(int argc, char **argv)
 		stat[i].recv_bits_total += can_frame_length(&frame,
 							    mode, nbytes);
 	}
-		}
-	}

-	for (i = 0; i < currmax; i++)
-		close(s[i]);
+	close(s);

 	if (signal_num)
 		return 128 + signal_num;
--- a/canerrsim.c
+++ b/canerrsim.c
@ -0,0 +1,564 @@
+////////////////////////////////////////////////////////////////////////////////////////////////////
+//                                                                                                //
+//  canerrsim - utility to simulate SocketCAN error messages, by Zeljko Avramovic (c) 2024        //
+//                                                                                                //
+//  SPDX-License-Identifier: LGPL-2.1-or-later OR BSD-3-Clause                                    //
+//                                                                                                //
+//  Virtual CAN adapter vcan0 is hard coded and you can bring it up like this:                    //
+//  sudo modprobe vcan                                                                            //
+//  sudo ip link add dev vcan0 type vcan                                                          //
+//  sudo ip link set vcan0 mtu 72              # needed for CAN FD                                //
+//  sudo ip link set vcan0 up                                                                     //
+//                                                                                                //
+//  To simulate error messages use canerrsim utility like this:                                   //
+//  ./canerrsim vcan0 LostArBit=09 Data4=AA TX BusOff NoAck ShowBits                              //
+//                                                                                                //
+//  That should show in canerrdump utility as:                                                    //
+//  0x06A [8] 09 00 80 00 AA 00 00 00  ERR=LostArBit09,NoAck,BusOff,Prot(Type(TX),Loc(Unspec))    //
+//                                                                                                //
+//  Alternatively, you could use candump from can-utils to check only error messages like this:   //
+//  candump -tA -e -c -a any,0~0,#FFFFFFFF                                                        //
+//                                                                                                //
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <linux/can.h>
+#include <linux/can/error.h>
+#include <linux/can/raw.h>
+#include <net/if.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+
+#define STR_EQUAL 0
+
+void show_help_and_exit()
+{
+	printf("\n");
+	printf("Usage: canerrsim <CAN interface> <options>\n");
+	printf("\n");
+	printf("CAN interface:          ( CAN interface is case sensitive )\n");
+	printf("    can0                ( or can1, can2 or virtual ones like vcan0, vcan1...\n");
+	printf("\n");
+	printf("Options:                ( options are not case sensitive )\n");
+	printf("                        ( ERROR CLASS (MASK) IN CAN ID: )\n");
+	printf("    TxTimeout           ( TX timeout by netdevice driver )\n");
+	printf("    NoAck               ( received no ACK on transmission )\n");
+	printf("    BusOff              ( bus off )\n");
+	printf("    BusError            ( bus error, may flood! )\n");
+	printf("    Restarted           ( controller restarted )\n");
+	printf("    TxCount=<00..FF>    ( TX error counter )\n");
+	printf("    RxCount=<00..FF>    ( RX error counter )\n");
+	printf("                        ( ARBITRATIONLOST IN CAN ID + BIT NUMBER IN DATA[0]: )\n");
+	printf("    LostArBit=<00..29>  ( decimal lost arbitration bit number in bitstream )\n");
+	printf("                        ( CONTROLLER IN CAN ID + ERROR STATUS IN DATA[1]: )\n");
+	printf("    OverflowRX          ( RX buffer overflow )\n");
+	printf("    OverflowTX          ( TX buffer overflow )\n");
+	printf("    WarningRX           ( reached warning level for RX errors )\n");
+	printf("    WarningTX           ( reached warning level for TX errors )\n");
+	printf("    PassiveRX           ( reached error passive status RX, errors > 127 )\n");
+	printf("    PassiveTX           ( reached error passive status TX, errors > 127 )\n");
+	printf("    Active              ( recovered to error active state )\n");
+	printf("                        ( PROTOCOL ERROR IN CAN ID + TYPE IN DATA[2]: )\n");
+	printf("    SingleBit           ( single bit error )\n");
+	printf("    FrameFormat         ( frame format error )\n");
+	printf("    BitStuffing         ( bit stuffing error )\n");
+	printf("    Bit0                ( unable to send dominant bit )\n");
+	printf("    Bit1                ( unable to send recessive bit )\n");
+	printf("    BusOverload         ( bus overload )\n");
+	printf("    ActiveAnnouncement  ( active error announcement )\n");
+	printf("    TX                  ( error occurred on transmission )\n");
+	printf("                        ( PROTOCOL ERROR IN CAN ID + LOCATION IN DATA[3]: )\n");
+	printf("    SOF                 ( start of frame )\n");
+	printf("    ID28_21             ( ID bits 21..28, SFF: 3..10 )\n");
+	printf("    ID20_18             ( ID bits 18..20, SFF: 0..2 )\n");
+	printf("    SRTR                ( substitute RTR, SFF: RTR )\n");
+	printf("    IDE                 ( identifier extension )\n");
+	printf("    ID17_13             ( ID bits 13..17 )\n");
+	printf("    ID12_05             ( ID bits 5..12 )\n");
+	printf("    ID04_00             ( ID bits 0..4 )\n");
+	printf("    RTR                 ( RTR )\n");
+	printf("    RES1                ( reserved bit 1 )\n");
+	printf("    RES0                ( reserved bit 0 )\n");
+	printf("    DLC                 ( data length code )\n");
+	printf("    DATA                ( data section )\n");
+	printf("    CRC_SEQ             ( CRC sequence )\n");
+	printf("    CRC_DEL             ( CRC delimiter )\n");
+	printf("    ACK                 ( ACK slot )\n");
+	printf("    ACK_DEL             ( ACK delimiter )\n");
+	printf("    EOF                 ( end of frame )\n");
+	printf("    INTERM              ( intermission )\n");
+	printf("                        ( TRANSCEIVER ERROR IN CAN ID + STATUS IN DATA[4]: )\n");
+	printf("                        ( CANH CANL )\n");
+	printf("    TransUnspec         ( 0000 0000 )\n");
+	printf("    CanHiNoWire         ( 0000 0100 )\n");
+	printf("    CanHiShortToBAT     ( 0000 0101 )\n");
+	printf("    CanHiShortToVCC     ( 0000 0110 )\n");
+	printf("    CanHiShortToGND     ( 0000 0111 )\n");
+	printf("    CanLoNoWire         ( 0100 0000 )\n");
+	printf("    CanLoShortToBAT     ( 0101 0000 )\n");
+	printf("    CanLoShortToVCC     ( 0110 0000 )\n");
+	printf("    CanLoShortToGND     ( 0111 0000 )\n");
+	printf("    CanLoShortToCanHi   ( 1000 0000 )\n");
+	printf("                        ( CUSTOM BYTE TO DATA[0..7]: )\n");
+	printf("    Data<0..7>=<00..FF> ( write hex number to one of 8 payload bytes )\n");
+	printf("                        ( DEBUG HELPERS: )\n");
+	printf("    ShowBits            ( display all frame bits )\n");
+	printf("\n");
+	printf("Examples:\n");
+	printf("\n");
+	printf("    ./canerrsim can1 LostArBit=09 Data3=AA Data4=BB ShowBits\n");
+	printf("    ( can1: 9th arb. bit lost, custom bytes in Data[3] and Data[4], show debug frame bits )\n");
+	printf("\n");
+	printf("    ./canerrsim vcan0 NoAck TxTimeout Active\n");
+	printf("    ( vcan0: received no ACK on transmission, driver timeout, protocol type active error announcement )\n");
+	printf("\n");
+	printf("    ./canerrsim vcan0 BusError CanHiNoWire Restarted INTERM\n");
+	printf("    ( vcan0: bus error, lost CANH wiring, controller restarted, protocol location intermission )\n");
+	printf("\n");
+	exit(EXIT_SUCCESS);
+}
+
+void err_exit(const char *msg)
+{
+	printf("%s", msg);
+	exit(EXIT_FAILURE);
+}
+
+void show_custom_format_and_exit(const char *param, const char *format)
+{
+	char str_buf[80];
+	sprintf(str_buf, format, param);
+	err_exit(str_buf);
+}
+
+void show_invalid_option(const char *option)
+{
+	show_custom_format_and_exit(option, "Error: Invalid option %s\n");
+}
+
+void show_err_and_exit(const char *err_type)
+{
+	show_custom_format_and_exit(err_type, "Error: You can only have one %s parameter!\n");
+}
+
+void show_loc_err_and_exit()
+{
+	show_err_and_exit("protocol location");
+}
+
+void show_arb_err_and_exit()
+{
+	show_err_and_exit("arbitration bit");
+}
+
+void show_transc_err_and_exit()
+{
+	show_err_and_exit("transceiver");
+}
+
+void print_binary(uint32_t number)
+{
+	uint32_t mask = 0x80000000; // start with the most significant bit
+	for (int i = 0; i < 32; i++) {
+		putchar((number & mask) ? '1' : '0');
+		mask >>= 1; // shift the mask to the right
+	}
+}
+
+int main(int argc, char *argv[])
+{
+	int sock;
+	struct sockaddr_can addr;
+	struct ifreq ifr;
+	struct can_frame frame;
+	bool show_bits = false, location_processed = false, transceiver_processed = false, arbitration_processed = false;
+	char tmp_str[256];
+
+	printf("CAN Sockets Error Messages Simulator\n");
+	if (argc < 3)
+		show_help_and_exit();
+
+	// initialize CAN frame
+	memset(&frame, 0, sizeof(frame));
+	frame.can_id = CAN_ERR_FLAG;
+	frame.can_dlc = CAN_ERR_DLC;
+
+	// Parse command line parameters
+	for (int i = 2; i < argc; i++) {
+		//printf("strlen(argv[%d]) = %d\n", i, strlen(argv[i]));
+
+		// error class (mask) in can_id
+		if (strcasecmp(argv[i], "TxTimeout") == STR_EQUAL)
+			frame.can_id |= CAN_ERR_TX_TIMEOUT; // generate TxTimeout error
+		else if (strcasecmp(argv[i], "NoAck") == STR_EQUAL)
+			frame.can_id |= CAN_ERR_ACK; // generate NoAck error
+		else if (strcasecmp(argv[i], "BusOff") == STR_EQUAL)
+			frame.can_id |= CAN_ERR_BUSOFF; // generate BusOff error
+		else if (strcasecmp(argv[i], "BusError") == STR_EQUAL)
+			frame.can_id |= CAN_ERR_BUSERROR; // generate BusError error
+		else if (strcasecmp(argv[i], "Restarted") == STR_EQUAL)
+			frame.can_id |= CAN_ERR_RESTARTED; // generate Restarted error
+		// error status of CAN controller / data[1]
+		else if (strcasecmp(argv[i], "OverflowRX") == STR_EQUAL) {
+			frame.can_id |= CAN_ERR_CRTL; // generate Controller error
+			frame.data[1] |= CAN_ERR_CRTL_RX_OVERFLOW; // generate RX Overflow suberror
+		} else if (strcasecmp(argv[i], "OverflowTX") == STR_EQUAL) {
+			frame.can_id |= CAN_ERR_CRTL; // generate Controller error
+			frame.data[1] |= CAN_ERR_CRTL_TX_OVERFLOW; // generate TX Overflow suberror
+		} else if (strcasecmp(argv[i], "WarningRX") == STR_EQUAL) {
+			frame.can_id |= CAN_ERR_CRTL; // generate Controller error
+			frame.data[1] |= CAN_ERR_CRTL_RX_WARNING; // generate RX Warning suberror
+		} else if (strcasecmp(argv[i], "WarningTX") == STR_EQUAL) {
+			frame.can_id |= CAN_ERR_CRTL; // generate Controller error
+			frame.data[1] |= CAN_ERR_CRTL_TX_WARNING; // generate TX Warning suberror
+		} else if (strcasecmp(argv[i], "PassiveRX") == STR_EQUAL) {
+			frame.can_id |= CAN_ERR_CRTL; // generate Controller error
+			frame.data[1] |= CAN_ERR_CRTL_RX_PASSIVE; // generate RX Passive suberror
+		} else if (strcasecmp(argv[i], "PassiveTX") == STR_EQUAL) {
+			frame.can_id |= CAN_ERR_CRTL; // generate Controller error
+			frame.data[1] |= CAN_ERR_CRTL_TX_PASSIVE; // generate TX Passive suberror
+		} else if (strcasecmp(argv[i], "Active") == STR_EQUAL) {
+			frame.can_id |= CAN_ERR_CRTL; // generate Controller error
+			frame.data[1] |= CAN_ERR_CRTL_ACTIVE; // generate Active suberror
+		} else if (strcasecmp(argv[i], "CtrlUnspec") == STR_EQUAL) {
+			frame.can_id |= CAN_ERR_CRTL; // generate Controller error
+			frame.data[1] = CAN_ERR_CRTL_UNSPEC; // generate Unspec suberror
+		}
+		// error in CAN protocol (type) / data[2]
+		else if (strcasecmp(argv[i], "SingleBit") == STR_EQUAL) {
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Type error
+			frame.data[2] = CAN_ERR_PROT_BIT; // generate SingleBit suberror
+		} else if (strcasecmp(argv[i], "FrameFormat") == STR_EQUAL) {
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Type error
+			frame.data[2] = CAN_ERR_PROT_FORM; // generate FrameFormat suberror
+		} else if (strcasecmp(argv[i], "BitStuffing") == STR_EQUAL) {
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Type error
+			frame.data[2] = CAN_ERR_PROT_STUFF; // generate BitStuffing suberror
+		} else if (strcasecmp(argv[i], "Bit0") == STR_EQUAL) {
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Type error
+			frame.data[2] = CAN_ERR_PROT_BIT0; // generate Bit0 suberror
+		} else if (strcasecmp(argv[i], "Bit1") == STR_EQUAL) {
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Type error
+			frame.data[2] = CAN_ERR_PROT_BIT1; // generate Bit1 suberror
+		} else if (strcasecmp(argv[i], "BusOverload") == STR_EQUAL) {
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Type error
+			frame.data[2] = CAN_ERR_PROT_OVERLOAD; // generate BusOverload suberror
+		} else if (strcasecmp(argv[i], "ActiveAnnouncement") == STR_EQUAL) {
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Type error
+			frame.data[2] = CAN_ERR_PROT_ACTIVE; // generate ActiveAnnouncement suberror
+		} else if (strcasecmp(argv[i], "TX") == STR_EQUAL) {
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Type error
+			frame.data[2] = CAN_ERR_PROT_TX; // generate TX suberror
+		} else if (strcasecmp(argv[i], "ProtUnspec") == STR_EQUAL) {
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Type error
+			frame.data[2] = CAN_ERR_PROT_UNSPEC; // generate Unspec suberror
+		}
+		// error in CAN protocol (location) / data[3]
+		else if (strcasecmp(argv[i], "LocUnspec") == STR_EQUAL) {
+			if (location_processed)
+				show_loc_err_and_exit();
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Location error
+			frame.data[3] = CAN_ERR_PROT_LOC_UNSPEC; // generate Unspec suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "SOF") == STR_EQUAL) {
+			if (location_processed)
+				show_loc_err_and_exit();
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Location error
+			frame.data[3] = CAN_ERR_PROT_LOC_SOF; // generate SOF suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "SOF") == STR_EQUAL) {
+			if (location_processed)
+				show_loc_err_and_exit();
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Location error
+			frame.data[3] = CAN_ERR_PROT_LOC_SOF; // generate SOF suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "ID28_21") == STR_EQUAL) {
+			if (location_processed)
+				show_loc_err_and_exit();
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Location error
+			frame.data[3] = CAN_ERR_PROT_LOC_ID28_21; // generate ID28_21 suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "ID20_18") == STR_EQUAL) {
+			if (location_processed)
+				show_loc_err_and_exit();
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Location error
+			frame.data[3] = CAN_ERR_PROT_LOC_ID20_18; // generate ID20_18 suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "SRTR") == STR_EQUAL) {
+			if (location_processed)
+				show_loc_err_and_exit();
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Location error
+			frame.data[3] = CAN_ERR_PROT_LOC_SRTR; // generate SRTR suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "IDE") == STR_EQUAL) {
+			if (location_processed)
+				show_loc_err_and_exit();
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Location error
+			frame.data[3] = CAN_ERR_PROT_LOC_IDE; // generate IDE suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "ID17_13") == STR_EQUAL) {
+			if (location_processed)
+				show_loc_err_and_exit();
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Location error
+			frame.data[3] = CAN_ERR_PROT_LOC_ID17_13; // generate ID17_13 suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "ID12_05") == STR_EQUAL) {
+			if (location_processed)
+				show_loc_err_and_exit();
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Location error
+			frame.data[3] = CAN_ERR_PROT_LOC_ID12_05; // generate ID12_05 suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "ID04_00") == STR_EQUAL) {
+			if (location_processed)
+				show_loc_err_and_exit();
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Location error
+			frame.data[3] = CAN_ERR_PROT_LOC_ID04_00; // generate ID04_00 suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "RTR") == STR_EQUAL) {
+			if (location_processed)
+				show_loc_err_and_exit();
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Location error
+			frame.data[3] = CAN_ERR_PROT_LOC_RTR; // generate RTR suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "RES1") == STR_EQUAL) {
+			if (location_processed)
+				show_loc_err_and_exit();
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Location error
+			frame.data[3] = CAN_ERR_PROT_LOC_RES1; // generate RES1 suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "RES0") == STR_EQUAL) {
+			if (location_processed)
+				show_loc_err_and_exit();
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Location error
+			frame.data[3] = CAN_ERR_PROT_LOC_RES0; // generate RES0 suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "DLC") == STR_EQUAL) {
+			if (location_processed)
+				show_loc_err_and_exit();
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Location error
+			frame.data[3] = CAN_ERR_PROT_LOC_DLC; // generate DLC suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "DATA") == STR_EQUAL) {
+			if (location_processed)
+				show_loc_err_and_exit();
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Location error
+			frame.data[3] = CAN_ERR_PROT_LOC_DATA; // generate DATA suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "CRC_SEQ") == STR_EQUAL) {
+			if (location_processed)
+				show_loc_err_and_exit();
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Location error
+			frame.data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; // generate CRC_SEQ suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "CRC_DEL") == STR_EQUAL) {
+			if (location_processed)
+				show_loc_err_and_exit();
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Location error
+			frame.data[3] = CAN_ERR_PROT_LOC_CRC_DEL; // generate CRC_DEL suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "ACK") == STR_EQUAL) {
+			if (location_processed)
+				show_loc_err_and_exit();
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Location error
+			frame.data[3] = CAN_ERR_PROT_LOC_ACK; // generate ACK suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "ACK_DEL") == STR_EQUAL) {
+			if (location_processed)
+				show_loc_err_and_exit();
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Location error
+			frame.data[3] = CAN_ERR_PROT_LOC_ACK_DEL; // generate ACK_DEL suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "EOF") == STR_EQUAL) {
+			if (location_processed)
+				show_loc_err_and_exit();
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Location error
+			frame.data[3] = CAN_ERR_PROT_LOC_EOF; // generate EOF suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "INTERM") == STR_EQUAL) {
+			if (location_processed)
+				show_loc_err_and_exit();
+			frame.can_id |= CAN_ERR_PROT; // generate Protocol Location error
+			frame.data[3] = CAN_ERR_PROT_LOC_INTERM; // generate INTERM suberror
+			location_processed = true;
+		}
+		// error status of CAN transceiver / data[4]
+		else if (strcasecmp(argv[i], "TransUnspec") == STR_EQUAL) {
+			if (transceiver_processed)
+				show_transc_err_and_exit();
+			frame.can_id |= CAN_ERR_TRX; // generate Transceiver error
+			frame.data[4] = CAN_ERR_TRX_UNSPEC; // generate EOF suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "CanHiNoWire") == STR_EQUAL) {
+			if (transceiver_processed)
+				show_transc_err_and_exit();
+			frame.can_id |= CAN_ERR_TRX; // generate Transceiver error
+			frame.data[4] = CAN_ERR_TRX_CANH_NO_WIRE; // generate CanHiNoWire suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "CanHiShortToBAT") == STR_EQUAL) {
+			if (transceiver_processed)
+				show_transc_err_and_exit();
+			frame.can_id |= CAN_ERR_TRX; // generate Transceiver error
+			frame.data[4] = CAN_ERR_TRX_CANH_SHORT_TO_BAT; // generate CanHiShortToBAT suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "CanHiShortToVCC") == STR_EQUAL) {
+			if (transceiver_processed)
+				show_transc_err_and_exit();
+			frame.can_id |= CAN_ERR_TRX; // generate Transceiver error
+			frame.data[4] = CAN_ERR_TRX_CANH_SHORT_TO_VCC; // generate CanHiShortToVCC suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "CanHiShortToGND") == STR_EQUAL) {
+			if (transceiver_processed)
+				show_transc_err_and_exit();
+			frame.can_id |= CAN_ERR_TRX; // generate Transceiver error
+			frame.data[4] = CAN_ERR_TRX_CANH_SHORT_TO_GND; // generate CanHiShortToGND suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "CanLoNoWire") == STR_EQUAL) {
+			if (transceiver_processed)
+				show_transc_err_and_exit();
+			frame.can_id |= CAN_ERR_TRX; // generate Transceiver error
+			frame.data[4] = CAN_ERR_TRX_CANL_NO_WIRE; // generate CanLoNoWire suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "CanLoShortToBAT") == STR_EQUAL) {
+			if (transceiver_processed)
+				show_transc_err_and_exit();
+			frame.can_id |= CAN_ERR_TRX; // generate Transceiver error
+			frame.data[4] = CAN_ERR_TRX_CANL_SHORT_TO_BAT; // generate CanLoShortToBAT suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "CanLoShortToVCC") == STR_EQUAL) {
+			if (transceiver_processed)
+				show_transc_err_and_exit();
+			frame.can_id |= CAN_ERR_TRX; // generate Transceiver error
+			frame.data[4] = CAN_ERR_TRX_CANL_SHORT_TO_VCC; // generate CanLoShortToVCC suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "CanLoShortToGND") == STR_EQUAL) {
+			if (transceiver_processed)
+				show_transc_err_and_exit();
+			frame.can_id |= CAN_ERR_TRX; // generate Transceiver error
+			frame.data[4] = CAN_ERR_TRX_CANL_SHORT_TO_GND; // generate CanLoShortToGND suberror
+			location_processed = true;
+		} else if (strcasecmp(argv[i], "CanLoShortToCanHi") == STR_EQUAL) {
+			if (transceiver_processed)
+				show_transc_err_and_exit();
+			frame.can_id |= CAN_ERR_TRX; // generate Transceiver error
+			frame.data[4] = CAN_ERR_TRX_CANL_SHORT_TO_CANH; // generate CanLoShortToCanHi suberror
+			location_processed = true;
+		}
+		// LostArBit=29 (Totallength=12)
+		else if ((strlen(argv[i]) == 12) && // 'LostArBit=29'
+			 (argv[i][9] == '=') && // '='
+			 (argv[i][10] >= '0' && argv[i][10] <= '2') && // valid bits are from 00 to 29 (in decimal)
+			 (argv[i][11] >= '0' && argv[i][11] <= '9')) { // valid bits are from 00 to 29 (in decimal)
+			unsigned char arb_bit_num = (argv[i][10] - '0') * 10 + argv[i][11] - '0'; // convert decimal bitnumber to byte
+			argv[i][9] = 0; // terminate string for comparison
+			if (strcasecmp(argv[i], "LostArBit") == STR_EQUAL) {
+				if (arbitration_processed)
+					show_arb_err_and_exit();
+				frame.can_id |= CAN_ERR_LOSTARB; // generate LostArbitartionBit error
+				frame.data[0] = arb_bit_num; // bitnumber
+				arbitration_processed = true;
+			} else {
+				argv[i][9] = '='; // undo string termination
+				show_invalid_option(argv[i]);
+			}
+		}
+		// Data1=F4 (Totallength=8)                            // since this does not set any error bit, has to be combined with other errors
+		else if ((strlen(argv[i]) == 8) && // 'Data1=F4'
+			 (argv[i][4] >= '0' && argv[i][4] <= '7') && // valid data bytes are from 0 to 7 (in decimal)
+			 (argv[i][5] == '=') && // '='
+			 ((argv[i][6] >= '0' && argv[i][6] <= '9') || (argv[i][6] >= 'A' && argv[i][6] <= 'F')) && // first hexadecimal digit
+			 ((argv[i][7] >= '0' && argv[i][7] <= '9') || (argv[i][6] >= 'A' && argv[i][6] <= 'F'))) { // second hexadecimal digit
+			unsigned char data_byte_value, data_byte_no = 0;
+			data_byte_no = argv[i][4] - '0'; // convert order number of data byte (Data1 to 1, Data2 to 2...)
+			data_byte_value = 0;
+			if (argv[i][6] >= 'A') // convert higher digit hexadecimal char to byte
+				data_byte_value += (argv[i][6] - 'A' + 10) * 16;
+			else
+				data_byte_value += (argv[i][6] - '0') * 16;
+			if (argv[i][7] >= 'A') // convert lower digit hexadecimal char to byte
+				data_byte_value += (argv[i][7] - 'A' + 10);
+			else
+				data_byte_value += (argv[i][7] - '0');
+			argv[i][4] = 0; // terminate string for comparison
+			if (strcasecmp(argv[i], "Data") == STR_EQUAL) {
+				if (transceiver_processed)
+					show_transc_err_and_exit();
+				frame.data[data_byte_no] = data_byte_value; // populate proper data byte
+				arbitration_processed = true;
+			} else {
+				argv[i][4] = data_byte_no + '0'; // undo string termination
+				show_invalid_option(argv[i]);
+			}
+		}
+		// RxCount=F4 or TxCount=3A (Totallength=10)
+		else if ((strlen(argv[i]) == 10) && // 'RxCounter=F4' or 'TxCounter=3A'
+			 (argv[i][7] == '=') && // '='
+			 ((argv[i][8] >= '0' && argv[i][8] <= '9') || (argv[i][8] >= 'A' && argv[i][8] <= 'F')) && // first hexadecimal digit
+			 ((argv[i][9] >= '0' && argv[i][9] <= '9') || (argv[i][9] >= 'A' && argv[i][9] <= 'F'))) { // second hexadecimal digit
+			unsigned char counter_value = 0;
+			if (argv[i][8] >= 'A') // convert higher digit hexadecimal char to byte
+				counter_value += (argv[i][8] - 'A' + 10) * 16;
+			else
+				counter_value += (argv[i][8] - '0') * 16;
+			if (argv[i][9] >= 'A') // convert lower digit hexadecimal char to byte
+				counter_value += (argv[i][9] - 'A' + 10);
+			else
+				counter_value += (argv[i][9] - '0');
+			argv[i][7] = 0; // terminate string for comparison
+			if (strcasecmp(argv[i], "TxCount") == STR_EQUAL) {
+				frame.can_id |= CAN_ERR_CNT; // generate TxCounter error
+				frame.data[6] = counter_value; // populate proper data byte
+			} else if (strcasecmp(argv[i], "RxCount") == STR_EQUAL) {
+				frame.can_id |= CAN_ERR_CNT; // generate RxCounter error
+				frame.data[7] = counter_value; // populate proper data byte
+			} else {
+				argv[i][7] = '='; // undo string termination
+				show_invalid_option(argv[i]);
+			}
+		} else if (strcasecmp(argv[i], "ShowBits") == STR_EQUAL) // DEBUG helper
+			show_bits = true; // Display frame as bits
+		else
+			show_invalid_option(argv[i]);
+	}
+
+	if (show_bits == true) {
+		printf("CAN ID   = ");
+		print_binary(frame.can_id);
+		printf("\n");
+		// printf("frame.can_dlc = %d\n", frame.can_dlc);
+		printf("CAN Data = ");
+		for (size_t i = 0; i < frame.can_dlc; i++)
+			printf("%02X ", frame.data[i]);
+		printf("\n");
+	}
+
+	// create socket
+	if ((sock = socket(PF_CAN, SOCK_RAW, CAN_RAW)) < 0)
+		err_exit("Error while opening socket");
+
+	// set interface name
+	strcpy(ifr.ifr_name, argv[1]); // can0, vcan0...
+	if (ioctl(sock, SIOCGIFINDEX, &ifr) < 0) {
+		sprintf(tmp_str, "Error setting CAN interface name %s", argv[1]);
+		err_exit(tmp_str);
+	}
+
+	// bind socket to the CAN interface
+	addr.can_family = AF_CAN;
+	addr.can_ifindex = ifr.ifr_ifindex;
+	if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0)
+		err_exit("Error in socket bind");
+
+	// Send CAN error frame
+	if (write(sock, &frame, sizeof(frame)) < 0)
+		err_exit("Error writing to socket");
+	else
+		printf("CAN error frame sent\n");
+
+	close(sock);
+
+	return 0;
+}
--- a/canfdtest.c
+++ b/canfdtest.c
@ -157,7 +157,7 @@ static int compare_frame(const struct canfd_frame *exp, const struct canfd_frame
 	} else {
 		for (i = 0; i < rec->len; i++) {
 			if (rec->data[i] != (uint8_t)(exp->data[i] + inc)) {
-				printf("Databyte %x mismatch!\n", i);
+				printf("Databyte 0x%x mismatch!\n", i);
 				print_compare(expected_can_id, exp->data, exp->len,
 				              rec->can_id, rec->data, rec->len, inc);
 				running = 0;
--- a/cangen.c
+++ b/cangen.c
@ -189,6 +189,7 @@ static void print_usage(char *prg)
 	fprintf(stderr, "         -A <mode>     (CAN XL AF generation mode - see below, no e/o mode)\n");
 	fprintf(stderr, "         -V <mode>     (CAN XL VCID generation mode - see below, no e/o mode)\n");
 	fprintf(stderr, "         -p <timeout>  (poll on -ENOBUFS to write frames with <timeout> ms)\n");
+	fprintf(stderr, "         -P <priority> (set socket priority using SO_PRIORITY)\n");
 	fprintf(stderr, "         -n <count>    (terminate after <count> CAN frames - default infinite)\n");
 	fprintf(stderr, "         -i            (ignore -ENOBUFS return values on write() syscalls)\n");
 	fprintf(stderr, "         -x            (disable local loopback of generated CAN frames)\n");
@ -479,6 +480,7 @@ int main(int argc, char **argv)
 	uint64_t incdata = 0;
 	__u8 *data; /* base pointer for CC/FD or XL data */
 	int incdlc = 0;
+	int priority = -1;
 	unsigned long rnd;
 	unsigned char fixdata[CANFD_MAX_DLEN];
 	unsigned char rand_position[CANFD_MAX_DLEN] = { 0 };
@ -512,7 +514,7 @@ int main(int argc, char **argv)
 		{ 0,		0,			0, 0 },
 	};

-	while ((opt = getopt_long(argc, argv, "g:atefbEXR8mI:L:D:F:S:A:V:p:n:ixc:vh?", long_options, NULL)) != -1) {
+	while ((opt = getopt_long(argc, argv, "g:atefbEXR8mI:L:D:F:S:A:V:p:P:n:ixc:vh?", long_options, NULL)) != -1) {
 		switch (opt) {
 		case 'g':
 			gap = strtod(optarg, NULL);
@ -682,6 +684,14 @@ int main(int argc, char **argv)
 			}
 			break;

+		case 'P':
+			priority = atoi(optarg);
+			if (priority < 0) {
+				printf("socket priority has to be >= 0\n");
+				exit(1);
+			}
+			break;
+
 		case 'i':
 			ignore_enobufs = true;
 			break;
@ -750,6 +760,16 @@ int main(int argc, char **argv)
 	 */
 	setsockopt(s, SOL_CAN_RAW, CAN_RAW_FILTER, NULL, 0);

+	/*
+	 * user can use tc to configure the queuing discipline (e.g. mqprio),
+	 * together with SO_PRIORITY option to specify the message send from
+	 * this socket should go to which queue.
+	 */
+	if (priority >= 0 &&
+	    setsockopt(s, SOL_SOCKET, SO_PRIORITY, &priority, sizeof(priority))) {
+		printf("error setting SO_PRIORITY\n");
+	}
+
 	if (loopback_disable) {
 		const int loopback = 0;

--- a/include/linux/can.h
+++ b/include/linux/can.h
@ -182,7 +182,7 @@ struct canfd_frame {
 /*
 * defined bits for canxl_frame.flags
 *
- * The canxl_frame.flags element contains two bits CANXL_XLF and CANXL_SEC
+ * The canxl_frame.flags element contains three bits CANXL_[XLF|SEC|RRS]
 * and shares the relative position of the struct can[fd]_frame.len element.
 * The CANXL_XLF bit ALWAYS needs to be set to indicate a valid CAN XL frame.
 * As a side effect setting this bit intentionally breaks the length checks
@ -192,6 +192,7 @@ struct canfd_frame {
 */
 #define CANXL_XLF 0x80 /* mandatory CAN XL frame flag (must always be set!) */
 #define CANXL_SEC 0x01 /* Simple Extended Content (security/segmentation) */
+#define CANXL_RRS 0x02 /* Remote Request Substitution */

 /* the 8-bit VCID is optionally placed in the canxl_frame.prio element */
 #define CANXL_VCID_OFFSET 16 /* bit offset of VCID in prio element */
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@ -22,6 +22,8 @@ struct regmap {
 };

 #define pr_info(...) fprintf(stdout, ## __VA_ARGS__)
+#define pr_err(...) fprintf(stderr, ## __VA_ARGS__)
+#define pr_warn(...) fprintf(stderr, ## __VA_ARGS__)
 #define pr_cont(...) fprintf(stdout, ## __VA_ARGS__)
 #define netdev_info(ndev, ...) fprintf(stdout, ## __VA_ARGS__)
 #define BUILD_BUG_ON(...)
--- a/isobusfs/isobusfs_cli.c
+++ b/isobusfs/isobusfs_cli.c
@ -336,7 +336,7 @@ int isobusfs_cli_process_events_and_tasks(struct isobusfs_priv *priv)
 	if (priv->state == ISOBUSFS_CLI_STATE_SELFTEST)
 		dont_wait = true;

-	ret = isobusfs_cmn_prepare_for_events(&priv->cmn, &nfds, dont_wait);
+	ret = libj1939_prepare_for_events(&priv->cmn, &nfds, dont_wait);
 	if (ret)
 		return ret;

@ -354,7 +354,7 @@ static int isobusfs_cli_sock_main_prepare(struct isobusfs_priv *priv)
 	struct sockaddr_can addr = priv->sockname;
 	int ret;

-	ret = isobusfs_cmn_open_socket();
+	ret = libj1939_open_socket();
 	if (ret < 0)
 		return ret;

@ -362,7 +362,7 @@ static int isobusfs_cli_sock_main_prepare(struct isobusfs_priv *priv)

 	/* TODO: this is TX only socket */
 	addr.can_addr.j1939.pgn = ISOBUSFS_PGN_FS_TO_CL;
-	ret = isobusfs_cmn_bind_socket(priv->sock_main, &addr);
+	ret = libj1939_bind_socket(priv->sock_main, &addr);
 	if (ret < 0)
 		return ret;

@ -370,7 +370,7 @@ static int isobusfs_cli_sock_main_prepare(struct isobusfs_priv *priv)
 	if (ret < 0)
 		return ret;

-	ret = isobusfs_cmn_socket_prio(priv->sock_main, ISOBUSFS_PRIO_DEFAULT);
+	ret = libj1939_socket_prio(priv->sock_main, ISOBUSFS_PRIO_DEFAULT);
 	if (ret < 0)
 		return ret;

@ -378,7 +378,7 @@ static int isobusfs_cli_sock_main_prepare(struct isobusfs_priv *priv)
 	if (ret < 0)
 		return ret;

-	return isobusfs_cmn_add_socket_to_epoll(priv->cmn.epoll_fd,
+	return libj1939_add_socket_to_epoll(priv->cmn.epoll_fd,
 						priv->sock_main, EPOLLIN);
 }

@ -398,7 +398,7 @@ static int isobusfs_cli_sock_int_prepare(struct isobusfs_priv *priv)
 	if (ret < 0)
 		return ret;

-	return isobusfs_cmn_add_socket_to_epoll(priv->cmn.epoll_fd,
+	return libj1939_add_socket_to_epoll(priv->cmn.epoll_fd,
 						STDIN_FILENO, EPOLLIN);
 }

@ -407,7 +407,7 @@ static int isobusfs_cli_sock_ccm_prepare(struct isobusfs_priv *priv)
 	struct sockaddr_can addr = priv->sockname;
 	int ret;

-	ret = isobusfs_cmn_open_socket();
+	ret = libj1939_open_socket();
 	if (ret < 0)
 		return ret;

@ -419,7 +419,7 @@ static int isobusfs_cli_sock_ccm_prepare(struct isobusfs_priv *priv)

 	/* TODO: this is TX only socket */
 	addr.can_addr.j1939.pgn = J1939_NO_PGN;
-	ret = isobusfs_cmn_bind_socket(priv->sock_ccm, &addr);
+	ret = libj1939_bind_socket(priv->sock_ccm, &addr);
 	if (ret < 0)
 		return ret;

@ -427,7 +427,7 @@ static int isobusfs_cli_sock_ccm_prepare(struct isobusfs_priv *priv)
 	if (ret < 0)
 		return ret;

-	ret = isobusfs_cmn_socket_prio(priv->sock_ccm, ISOBUSFS_PRIO_DEFAULT);
+	ret = libj1939_socket_prio(priv->sock_ccm, ISOBUSFS_PRIO_DEFAULT);
 	if (ret < 0)
 		return ret;

@ -436,7 +436,7 @@ static int isobusfs_cli_sock_ccm_prepare(struct isobusfs_priv *priv)
 		return ret;

 	/* poll for errors to get confirmation if our packets are send */
-	return isobusfs_cmn_add_socket_to_epoll(priv->cmn.epoll_fd, priv->sock_ccm,
+	return libj1939_add_socket_to_epoll(priv->cmn.epoll_fd, priv->sock_ccm,
 						EPOLLERR);
 }

@ -445,23 +445,23 @@ static int isobusfs_cli_sock_nack_prepare(struct isobusfs_priv *priv)
 	struct sockaddr_can addr = priv->sockname;
 	int ret;

-	ret = isobusfs_cmn_open_socket();
+	ret = libj1939_open_socket();
 	if (ret < 0)
 		return ret;

 	priv->sock_nack = ret;

 	addr.can_addr.j1939.pgn = ISOBUS_PGN_ACK;
-	ret = isobusfs_cmn_bind_socket(priv->sock_nack, &addr);
+	ret = libj1939_bind_socket(priv->sock_nack, &addr);
 	if (ret < 0)
 		return ret;

-	ret = isobusfs_cmn_socket_prio(priv->sock_nack, ISOBUSFS_PRIO_ACK);
+	ret = libj1939_socket_prio(priv->sock_nack, ISOBUSFS_PRIO_ACK);
 	if (ret < 0)
 		return ret;

 	/* poll for errors to get confirmation if our packets are send */
-	return isobusfs_cmn_add_socket_to_epoll(priv->cmn.epoll_fd,
+	return libj1939_add_socket_to_epoll(priv->cmn.epoll_fd,
 						priv->sock_nack, EPOLLIN);
 }

@ -471,7 +471,7 @@ static int isobusfs_cli_sock_bcast_prepare(struct isobusfs_priv *priv)
 	struct sockaddr_can addr = priv->sockname;
 	int ret;

-	ret = isobusfs_cmn_open_socket();
+	ret = libj1939_open_socket();
 	if (ret < 0)
 		return ret;

@ -481,11 +481,11 @@ static int isobusfs_cli_sock_bcast_prepare(struct isobusfs_priv *priv)
 	addr.can_addr.j1939.name = J1939_NO_NAME;
 	addr.can_addr.j1939.addr = J1939_NO_ADDR;
 	addr.can_addr.j1939.pgn = ISOBUSFS_PGN_FS_TO_CL;
-	ret = isobusfs_cmn_bind_socket(priv->sock_bcast_rx, &addr);
+	ret = libj1939_bind_socket(priv->sock_bcast_rx, &addr);
 	if (ret < 0)
 		return ret;

-	ret = isobusfs_cmn_set_broadcast(priv->sock_bcast_rx);
+	ret = libj1939_set_broadcast(priv->sock_bcast_rx);
 	if (ret < 0)
 		return ret;

@ -493,7 +493,7 @@ static int isobusfs_cli_sock_bcast_prepare(struct isobusfs_priv *priv)
 	if (ret < 0)
 		return ret;

-	return isobusfs_cmn_add_socket_to_epoll(priv->cmn.epoll_fd, priv->sock_bcast_rx,
+	return libj1939_add_socket_to_epoll(priv->cmn.epoll_fd, priv->sock_bcast_rx,
 						EPOLLIN);
 }

@ -501,7 +501,7 @@ static int isobusfs_cli_sock_prepare(struct isobusfs_priv *priv)
 {
 	int ret;

-	ret = isobusfs_cmn_create_epoll();
+	ret = libj1939_create_epoll();
 	if (ret < 0)
 		return ret;

@ -647,8 +647,8 @@ int main(int argc, char *argv[])

 	bzero(priv, sizeof(*priv));

-	isobusfs_init_sockaddr_can(&priv->sockname, J1939_NO_PGN);
-	isobusfs_init_sockaddr_can(&priv->peername, ISOBUSFS_PGN_CL_TO_FS);
+	libj1939_init_sockaddr_can(&priv->sockname, J1939_NO_PGN);
+	libj1939_init_sockaddr_can(&priv->peername, ISOBUSFS_PGN_CL_TO_FS);

 	ret = isobusfs_cli_parse_args(priv, argc, argv);
 	if (ret)
--- a/isobusfs/isobusfs_cli.h
+++ b/isobusfs/isobusfs_cli.h
@ -103,7 +103,7 @@ struct isobusfs_priv {
 	struct isobusfs_buf_log tx_buf_log;
 	enum isobusfs_cli_state state;

-	struct isobusfs_cmn cmn;
+	struct libj1939_cmn cmn;
 	uint8_t handle;

 	uint32_t read_offset;
--- a/isobusfs/isobusfs_cli_int.c
+++ b/isobusfs/isobusfs_cli_int.c
@ -1077,7 +1077,7 @@ int isobusfs_cli_interactive(struct isobusfs_priv *priv)
 			}
 		}

-		pr_int("unknown comand\n");
+		pr_int("unknown command\n");
 		isobusfs_cli_promt(priv);
 	} else {
 		if (errno != EAGAIN && errno != EWOULDBLOCK)
--- a/isobusfs/isobusfs_cli_selftests.c
+++ b/isobusfs/isobusfs_cli_selftests.c
@ -211,7 +211,7 @@ static struct isobusfs_cli_test_dir_path test_dir_patterns[] = {
 	{ "~tilde_dir", true },
 	/* expected result \\vol1\dir1\~\ */
 	{ "\\\\vol1\\dir1\\~", true },
-	/* expected result \\vol1\~\ not clear if it is manufacture speficic dir */
+	/* expected result \\vol1\~\ not clear if it is manufacture specific dir */
 	{ "\\~\\", true },
 	/* expected result \\~\ */
 	{ "\\\\~\\", false },
--- a/isobusfs/isobusfs_cmn.c
+++ b/isobusfs/isobusfs_cmn.c
@ -125,29 +125,6 @@ void isobusfs_log_level_set(log_level_t level)
 	log_level = level;
 }

-int isobusfs_get_timeout_ms(struct timespec *ts)
-{
-	struct timespec curr_time;
-	int64_t time_diff;
-	int timeout_ms;
-
-	clock_gettime(CLOCK_MONOTONIC, &curr_time);
-	time_diff = timespec_diff_ms(ts, &curr_time);
-	if (time_diff < 0) {
-		/* Too late to send next message. Send it now */
-		timeout_ms = 0;
-	} else {
-		if (time_diff > INT_MAX) {
-			warn("timeout too long: %" PRId64 " ms", time_diff);
-			time_diff = INT_MAX;
-		}
-
-		timeout_ms = time_diff;
-	}
-
-	return timeout_ms;
-}
-
 const char *isobusfs_error_to_str(enum isobusfs_error err)
 {
 	switch (err) {
@ -238,15 +215,6 @@ enum isobusfs_error linux_error_to_isobusfs_error(int linux_err)
 	}
 }

-
-void isobusfs_init_sockaddr_can(struct sockaddr_can *sac, uint32_t pgn)
-{
-	sac->can_family = AF_CAN;
-	sac->can_addr.j1939.addr = J1939_NO_ADDR;
-	sac->can_addr.j1939.name = J1939_NO_NAME;
-	sac->can_addr.j1939.pgn = pgn;
-}
-
 static void isobusfs_print_timestamp(struct isobusfs_err_msg *emsg,
 				     const char *name, struct timespec *cur)
 {
@ -520,28 +488,6 @@ int isobusfs_send(int sock, const void *data, size_t len,
 	return 0;
 }

-/**
- * isobusfs_cmn_open_socket - Open a CAN J1939 socket
- *
- * This function opens a CAN J1939 socket and returns the file descriptor
- * on success. In case of an error, the function returns the negative
- * error code.
- */
-int isobusfs_cmn_open_socket(void)
-{
-	int ret;
-
-	/* Create a new CAN J1939 socket */
-	ret = socket(PF_CAN, SOCK_DGRAM, CAN_J1939);
-	if (ret < 0) {
-		/* Get the error code and print an error message */
-		ret = -errno;
-		pr_err("socket(j1939): %d (%s)", ret, strerror(ret));
-		return ret;
-	}
-	return ret;
-}
-
 /**
 * isobusfs_cmn_configure_socket_filter - Configure a J1939 socket filter
 * @sock: Socket file descriptor
@ -650,47 +596,6 @@ int isobusfs_cmn_configure_error_queue(int sock)
 	return 0;
 }

-/**
- * isobusfs_cmn_bind_socket - Bind a J1939 socket to a given address
- * @sock: socket file descriptor
- * @addr: pointer to a sockaddr_can structure containing the address
- *         information to bind the socket to
- *
- * This function binds a J1939 socket to the specified address. It returns
- * 0 on successful binding or a negative error code on failure.
- *
- * Return: 0 on success, or a negative error code on failure.
- */
-int isobusfs_cmn_bind_socket(int sock, struct sockaddr_can *addr)
-{
-	int ret;
-
-	ret = bind(sock, (void *)addr, sizeof(*addr));
-	if (ret < 0) {
-		ret = -errno;
-		pr_err("failed to bind: %d (%s)", ret, strerror(ret));
-		return ret;
-	}
-
-	return 0;
-}
-
-int isobusfs_cmn_socket_prio(int sock, int prio)
-{
-	int ret;
-
-	ret = setsockopt(sock, SOL_CAN_J1939, SO_J1939_SEND_PRIO,
-			 &prio, sizeof(prio));
-	if (ret < 0) {
-		ret = -errno;
-		pr_warn("Failed to set priority %i. Error %i (%s)", prio, ret,
-			strerror(ret));
-		return ret;
-	}
-
-	return 0;
-}
-
 int isobusfs_cmn_connect_socket(int sock, struct sockaddr_can *addr)
 {
 	int ret;
@ -705,34 +610,8 @@ int isobusfs_cmn_connect_socket(int sock, struct sockaddr_can *addr)
 	return 0;
 }

-/**
- * isobusfs_cmn_set_broadcast - Enable broadcast option for a socket
- * @sock: socket file descriptor
- *
- * This function enables the SO_BROADCAST option for the given socket,
- * allowing it to send and receive broadcast messages. It returns 0 on success
- * or a negative error code on failure.
- *
- * Return: 0 on success, or a negative error code on failure.
- */
-int isobusfs_cmn_set_broadcast(int sock)
-{
-	int broadcast = true;
-	int ret;
-
-	ret = setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &broadcast,
-			 sizeof(broadcast));
-	if (ret < 0) {
-		ret = -errno;
-		pr_err("setsockopt(SO_BROADCAST): %d (%s)", ret, strerror(ret));
-		return ret;
-	}
-
-	return 0;
-}
-
 /* FIXME: linger is currently not supported by the kernel J1939 stack
- * but it would be nice to have it. Especially if we wont to stop sending
+ * but it would be nice to have it. Especially if we won't to stop sending
 * messages on a socket when the connection is lost.
 */
 int isobusfs_cmn_set_linger(int sock)
@ -753,70 +632,6 @@ int isobusfs_cmn_set_linger(int sock)
 	return 0;
 }

-int isobusfs_cmn_add_socket_to_epoll(int epoll_fd, int sock, uint32_t events)
-{
-	struct epoll_event ev = {0};
-	int ret;
-
-	ev.events = events;
-	ev.data.fd = sock;
-
-	ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sock, &ev);
-	if (ret < 0) {
-		ret = errno;
-		pr_err("epoll_ctl(EPOLL_CTL_ADD): %d (%s)", ret, strerror(ret));
-		return ret;
-	}
-
-	return 0;
-}
-
-int isobusfs_cmn_create_epoll(void)
-{
-	int ret, epoll_fd;
-
-	epoll_fd = epoll_create1(0);
-	if (epoll_fd < 0) {
-		ret = -errno;
-		pr_err("epoll_create1: %d (%s)", ret, strerror(ret));
-		return ret;
-	}
-
-	return epoll_fd;
-}
-
-int isobusfs_cmn_prepare_for_events(struct isobusfs_cmn *cmn, int *nfds,
-				    bool dont_wait)
-{
-	int ret, timeout_ms;
-
-	if (dont_wait)
-		timeout_ms = 0;
-	else
-		timeout_ms = isobusfs_get_timeout_ms(&cmn->next_send_time);
-
-	ret = epoll_wait(cmn->epoll_fd, cmn->epoll_events,
-			 cmn->epoll_events_size, timeout_ms);
-	if (ret < 0) {
-		ret = -errno;
-		if (ret != -EINTR) {
-			*nfds = 0;
-			return ret;
-		}
-	}
-
-	*nfds = ret;
-
-	ret = clock_gettime(CLOCK_MONOTONIC, &cmn->last_time);
-	if (ret < 0) {
-		ret = -errno;
-		pr_err("failed to get time: %i (%s)", ret, strerror(ret));
-		return ret;
-	}
-
-	return 0;
-}
-
 void isobusfs_cmn_dump_last_x_bytes(const uint8_t *buffer, size_t buffer_size,
 				    size_t x)
 {
--- a/isobusfs/isobusfs_cmn.h
+++ b/isobusfs/isobusfs_cmn.h
@ -257,15 +257,6 @@ struct isobusfs_err_msg {
 	struct isobusfs_stats *stats;
 };

-struct isobusfs_cmn {
-	int epoll_fd;
-	struct epoll_event *epoll_events;
-	size_t epoll_events_size;
-	struct timespec next_send_time;
-	struct timespec last_time;
-};
-
-void isobusfs_init_sockaddr_can(struct sockaddr_can *sac, uint32_t pgn);
 int isobusfs_recv_err(int sock, struct isobusfs_err_msg *emsg);

 /*
@ -300,7 +291,6 @@ static inline uint8_t isobusfs_cg_function_to_buf(enum isobusfs_cg cg,
 const char *isobusfs_error_to_str(enum isobusfs_error err);
 enum isobusfs_error linux_error_to_isobusfs_error(int linux_err);

-int isobusfs_get_timeout_ms(struct timespec *ts);
 void isobusfs_send_nack(int sock, struct isobusfs_msg *msg);
 void isobufs_store_tx_data(struct isobusfs_buf_log *buffer, uint8_t *data);
 void isobusfs_dump_tx_data(const struct isobusfs_buf_log *buffer);
@ -313,20 +303,11 @@ int isobusfs_send(int sock, const void *data, size_t len,
 void isobusfs_cmn_dump_last_x_bytes(const uint8_t *buffer, size_t buffer_size,
 				    size_t x);

-int isobusfs_cmn_open_socket(void);
 int isobusfs_cmn_configure_socket_filter(int sock, pgn_t pgn);
 int isobusfs_cmn_configure_error_queue(int sock);
-int isobusfs_cmn_bind_socket(int sock, struct sockaddr_can *addr);
 int isobusfs_cmn_connect_socket(int sock, struct sockaddr_can *addr);
-int isobusfs_cmn_set_broadcast(int sock);
-int isobusfs_cmn_add_socket_to_epoll(int epoll_fd, int sock, uint32_t events);
-int isobusfs_cmn_create_epoll(void);
-int isobusfs_cmn_socket_prio(int sock, int prio);
 int isobusfs_cmn_set_linger(int sock);

-int isobusfs_cmn_prepare_for_events(struct isobusfs_cmn *cmn, int *nfds,
-				    bool dont_wait);
-
 /* ============ directory handling ============ */
 int isobusfs_cmn_dh_validate_dir_path(const char *path, bool writable);

--- a/isobusfs/isobusfs_cmn_dh.c
+++ b/isobusfs/isobusfs_cmn_dh.c
@ -23,7 +23,7 @@ int isobusfs_cmn_dh_validate_dir_path(const char *path, bool writable)
 	ret = access(path, mode);
 	if (ret == -1) {
 		ret = -errno;
-		pr_err("failed to acces path %s, for read %s. %s", path,
+		pr_err("failed to access path %s, for read %s. %s", path,
 		       writable ? "and write" : "", strerror(ret));
 		return ret;
 	}
--- a/isobusfs/isobusfs_srv.c
+++ b/isobusfs/isobusfs_srv.c
@ -70,7 +70,7 @@ static int isobusfs_srv_rx_fs(struct isobusfs_srv_priv *priv,
 		      cg);

 		/* ISO 11783-13:2021 - Annex C.1.1 Overview:
-		 * If a client sends a command, which is not defined withing this
+		 * If a client sends a command, which is not defined within this
 		 * documentation, the file server shall respond with a
 		 * NACK (ISO 11783-3:2018 Chapter 5.4.5)
 		 */
@ -250,7 +250,7 @@ static int isobusfs_srv_process_events_and_tasks(struct isobusfs_srv_priv *priv)
 {
 	int ret, nfds;

-	ret = isobusfs_cmn_prepare_for_events(&priv->cmn, &nfds, false);
+	ret = libj1939_prepare_for_events(&priv->cmn, &nfds, false);
 	if (ret)
 		return ret;

@ -268,7 +268,7 @@ static int isobusfs_srv_sock_fss_prepare(struct isobusfs_srv_priv *priv)
 	struct sockaddr_can addr = priv->addr;
 	int ret;

-	ret = isobusfs_cmn_open_socket();
+	ret = libj1939_open_socket();
 	if (ret < 0)
 		return ret;

@ -279,15 +279,15 @@ static int isobusfs_srv_sock_fss_prepare(struct isobusfs_srv_priv *priv)
 		return ret;

 	/* keep address and name and overwrite PGN */
-	/* TOOD: actually, this is PGN input filter. Should we use different
+	/* TODO: actually, this is PGN input filter. Should we use different
 	 * PGN?
 	 */
 	addr.can_addr.j1939.pgn = ISOBUSFS_PGN_CL_TO_FS;
-	ret = isobusfs_cmn_bind_socket(priv->sock_fss, &addr);
+	ret = libj1939_bind_socket(priv->sock_fss, &addr);
 	if (ret < 0)
 		return ret;

-	ret = isobusfs_cmn_set_broadcast(priv->sock_fss);
+	ret = libj1939_set_broadcast(priv->sock_fss);
 	if (ret < 0)
 		return ret;

@ -295,7 +295,7 @@ static int isobusfs_srv_sock_fss_prepare(struct isobusfs_srv_priv *priv)
 	if (ret < 0)
 		return ret;

-	ret = isobusfs_cmn_socket_prio(priv->sock_fss, ISOBUSFS_PRIO_FSS);
+	ret = libj1939_socket_prio(priv->sock_fss, ISOBUSFS_PRIO_FSS);
 	if (ret < 0)
 		return ret;

@ -308,7 +308,7 @@ static int isobusfs_srv_sock_fss_prepare(struct isobusfs_srv_priv *priv)
 		return ret;

 	/* poll for errors to get confirmation if our packets are send */
-	return isobusfs_cmn_add_socket_to_epoll(priv->cmn.epoll_fd, priv->sock_fss,
+	return libj1939_add_socket_to_epoll(priv->cmn.epoll_fd, priv->sock_fss,
 						EPOLLERR);
 }

@ -317,7 +317,7 @@ static int isobusfs_srv_sock_in_prepare(struct isobusfs_srv_priv *priv)
 	struct sockaddr_can addr = priv->addr;
 	int ret;

-	ret = isobusfs_cmn_open_socket();
+	ret = libj1939_open_socket();
 	if (ret < 0)
 		return ret;

@ -325,11 +325,11 @@ static int isobusfs_srv_sock_in_prepare(struct isobusfs_srv_priv *priv)

 	/* keep address and name and overwrite PGN */
 	addr.can_addr.j1939.pgn = ISOBUSFS_PGN_CL_TO_FS;
-	ret = isobusfs_cmn_bind_socket(priv->sock_in, &addr);
+	ret = libj1939_bind_socket(priv->sock_in, &addr);
 	if (ret < 0)
 		return ret;

-	return isobusfs_cmn_add_socket_to_epoll(priv->cmn.epoll_fd, priv->sock_in,
+	return libj1939_add_socket_to_epoll(priv->cmn.epoll_fd, priv->sock_in,
 					    EPOLLIN);
 }

@ -338,23 +338,23 @@ static int isobusfs_srv_sock_nack_prepare(struct isobusfs_srv_priv *priv)
 	struct sockaddr_can addr = priv->addr;
 	int ret;

-	ret = isobusfs_cmn_open_socket();
+	ret = libj1939_open_socket();
 	if (ret < 0)
 		return ret;

 	priv->sock_nack = ret;

 	addr.can_addr.j1939.pgn = ISOBUS_PGN_ACK;
-	ret = isobusfs_cmn_bind_socket(priv->sock_nack, &addr);
+	ret = libj1939_bind_socket(priv->sock_nack, &addr);
 	if (ret < 0)
 		return ret;

-	ret = isobusfs_cmn_socket_prio(priv->sock_nack, ISOBUSFS_PRIO_ACK);
+	ret = libj1939_socket_prio(priv->sock_nack, ISOBUSFS_PRIO_ACK);
 	if (ret < 0)
 		return ret;

 	/* poll for errors to get confirmation if our packets are send */
-	return isobusfs_cmn_add_socket_to_epoll(priv->cmn.epoll_fd,
+	return libj1939_add_socket_to_epoll(priv->cmn.epoll_fd,
 					    priv->sock_nack, EPOLLIN);
 }

@ -370,7 +370,7 @@ static int isobusfs_srv_sock_prepare(struct isobusfs_srv_priv *priv)
 {
 	int ret;

-	ret = isobusfs_cmn_create_epoll();
+	ret = libj1939_create_epoll();
 	if (ret < 0)
 		return ret;

@ -720,7 +720,7 @@ static int isobusfs_srv_parse_args(struct isobusfs_srv_priv *priv, int argc,
 	}

 	if (!local_name_set)
-		pr_warn("local name is not set. Wont be able to generate proper manufacturer-specific directory name. Falling mack to MCMC0000");
+		pr_warn("local name is not set. Won't be able to generate proper manufacturer-specific directory name. Falling mack to MCMC0000");
 	isobusfs_srv_generate_mfs_dir_name(priv);

 	pr_debug("Server configuration:");
@ -762,7 +762,7 @@ int main(int argc, char *argv[])
 	memset(priv, 0, sizeof(*priv));

 	/* Initialize sockaddr_can with a non-configurable PGN */
-	isobusfs_init_sockaddr_can(&priv->addr, J1939_NO_PGN);
+	libj1939_init_sockaddr_can(&priv->addr, J1939_NO_PGN);

 	priv->server_version = ISOBUSFS_SRV_VERSION;
 	/* Parse command line arguments */
--- a/isobusfs/isobusfs_srv.h
+++ b/isobusfs/isobusfs_srv.h
@ -103,7 +103,7 @@ struct isobusfs_srv_priv {
 	int clients_count;
 	struct isobusfs_buf_log tx_buf_log;

-	struct isobusfs_cmn cmn;
+	struct libj1939_cmn cmn;

 	struct isobusfs_srv_volume volumes[ISOBUSFS_SRV_MAX_VOLUMES];
 	int volume_count;
--- a/isobusfs/isobusfs_srv_cm.c
+++ b/isobusfs/isobusfs_srv_cm.c
@ -213,14 +213,14 @@ static int isobusfs_srv_init_client(struct isobusfs_srv_priv *priv,
 		return -EINVAL;
 	}

-	ret = isobusfs_cmn_open_socket();
+	ret = libj1939_open_socket();
 	if (ret < 0)
 		return ret;

 	client->sock = ret;

 	addr.can_addr.j1939.pgn = ISOBUSFS_PGN_CL_TO_FS;
-	ret = isobusfs_cmn_bind_socket(client->sock, &addr);
+	ret = libj1939_bind_socket(client->sock, &addr);
 	if (ret < 0)
 		return ret;

@ -243,7 +243,7 @@ static int isobusfs_srv_init_client(struct isobusfs_srv_priv *priv,
 		goto close_socket;
 	}

-	ret = isobusfs_cmn_socket_prio(client->sock, ISOBUSFS_PRIO_DEFAULT);
+	ret = libj1939_socket_prio(client->sock, ISOBUSFS_PRIO_DEFAULT);
 	if (ret < 0)
 		return ret;

--- a/isobusfs/isobusfs_srv_dh.c
+++ b/isobusfs/isobusfs_srv_dh.c
@ -662,7 +662,7 @@ static int isobusfs_srv_dh_ccd_res(struct isobusfs_srv_priv *priv,
 	int ret;

 	/*
-	 * We assime, the relative path stored in res->name is not longer
+	 * We assume, the relative path stored in res->name is not longer
 	 * than absolue path
 	 */
 	if (req->name_len > ISOBUSFS_SRV_MAX_PATH_LEN) {
--- a/isobusfs/isobusfs_srv_fa.c
+++ b/isobusfs/isobusfs_srv_fa.c
@ -686,7 +686,7 @@ send_response:
 		goto free_res;
 	}

-	pr_debug("> tx: Read File Response. Error code: %d (%s), readed size: %d",
+	pr_debug("> tx: Read File Response. Error code: %d (%s), read size: %d",
 		 error_code, isobusfs_error_to_str(error_code), readed_size);

 free_res:
--- a/isotpdump.c
+++ b/isotpdump.c
@ -72,6 +72,7 @@ void print_usage(char *prg)
 	fprintf(stderr, "Options:\n");
 	fprintf(stderr, "         -s <can_id>  (source can_id. Use 8 digits for extended IDs)\n");
 	fprintf(stderr, "         -d <can_id>  (destination can_id. Use 8 digits for extended IDs)\n");
+	fprintf(stderr, "         -b <can_id>  (broadcast can_id, Use 8 digits for extended IDs)\n");
 	fprintf(stderr, "         -x <addr>    (extended addressing mode. Use 'any' for all addresses)\n");
 	fprintf(stderr, "         -X <addr>    (extended addressing mode (rx addr). Use 'any' for all)\n");
 	fprintf(stderr, "         -c           (color mode)\n");
@ -197,11 +198,12 @@ int main(int argc, char **argv)
 {
 	int s;
 	struct sockaddr_can addr;
-	struct can_filter rfilter[2];
+	struct can_filter rfilter[3];
 	struct canfd_frame frame;
 	int nbytes, i;
 	canid_t src = NO_CAN_ID;
 	canid_t dst = NO_CAN_ID;
+	canid_t bst = NO_CAN_ID;
 	int ext = 0;
 	int extaddr = 0;
 	int extany = 0;
@ -222,7 +224,7 @@ int main(int argc, char **argv)
 	last_tv.tv_sec  = 0;
 	last_tv.tv_usec = 0;

-	while ((opt = getopt(argc, argv, "s:d:ax:X:ct:u?")) != -1) {
+	while ((opt = getopt(argc, argv, "s:d:b:ax:X:ct:u?")) != -1) {
 		switch (opt) {
 		case 's':
 			src = strtoul(optarg, NULL, 16);
@ -236,6 +238,12 @@ int main(int argc, char **argv)
 				dst |= CAN_EFF_FLAG;
 			break;

+		case 'b':
+			bst = strtoul(optarg, NULL, 16);
+			if (strlen(optarg) > 7)
+				bst |= CAN_EFF_FLAG;
+			break;
+
 		case 'c':
 			color = 1;
 			break;
@ -321,7 +329,18 @@ int main(int argc, char **argv)
 		rfilter[1].can_mask = (CAN_SFF_MASK|CAN_EFF_FLAG|CAN_RTR_FLAG);
 	}

+	if (bst & CAN_EFF_FLAG) {
+		rfilter[2].can_id   = bst & (CAN_EFF_MASK | CAN_EFF_FLAG);
+		rfilter[2].can_mask = (CAN_EFF_MASK|CAN_EFF_FLAG|CAN_RTR_FLAG);
+	} else {
+		rfilter[2].can_id   = bst & CAN_SFF_MASK;
+		rfilter[2].can_mask = (CAN_SFF_MASK|CAN_EFF_FLAG|CAN_RTR_FLAG);
+	}
+
+	if (bst != NO_CAN_ID)
 		setsockopt(s, SOL_CAN_RAW, CAN_RAW_FILTER, &rfilter, sizeof(rfilter));
+	else
+		setsockopt(s, SOL_CAN_RAW, CAN_RAW_FILTER, &rfilter, sizeof(rfilter) - sizeof(rfilter[0]));

 	addr.can_family = AF_CAN;
 	addr.can_ifindex = if_nametoindex(argv[optind]);
@ -353,8 +372,14 @@ int main(int argc, char **argv)
 		    rx_extaddr != frame.data[0])
 			continue;

-		if (color)
-			printf("%s", (frame.can_id == src) ? FGRED : FGBLUE);
+		if (color) {
+			if (frame.can_id == src)
+				printf("%s", FGRED);
+			else if (frame.can_id == dst)
+				printf("%s", FGBLUE);
+			else if (frame.can_id == bst)
+				printf("%s", FGGREEN);
+		}

 		if (timestamp) {
 			ioctl(s, SIOCGSTAMP, &tv);
--- a/j1939_timedate/j1939_timedate_cli.c
+++ b/j1939_timedate/j1939_timedate_cli.c
@ -0,0 +1,500 @@
+// SPDX-License-Identifier: LGPL-2.0-only
+// SPDX-FileCopyrightText: 2024 Oleksij Rempel <linux@rempel-privat.de>
+
+#include <err.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <linux/kernel.h>
+#include <net/if.h>
+#include <poll.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "j1939_timedate_cmn.h"
+
+#define J1939_TIMEDATE_CLI_MAX_EPOLL_EVENTS	10
+
+struct j1939_timedate_cli_priv {
+	int sock_nack;
+	int sock_main;
+
+	struct sockaddr_can sockname;
+	struct sockaddr_can peername;
+
+	struct j1939_timedate_stats stats;
+
+	struct libj1939_cmn cmn;
+	struct timespec wait_until_time;
+
+	bool utc;
+	bool broadcast;
+	bool done;
+};
+
+static void print_time_date_packet(struct j1939_timedate_cli_priv *priv,
+				   const struct j1939_timedate_msg *msg)
+{
+	const struct j1939_time_date_packet *tdp =
+		(const struct j1939_time_date_packet *)msg->buf;
+	char timezone_offset[] = "+00:00 (Local Time)";
+	char time_buffer[64];
+	int actual_hour, actual_minute;
+	int actual_year, actual_month;
+	double actual_seconds;
+	double actual_day;
+
+	if (msg->len < (int)sizeof(*tdp)) {
+		pr_warn("received too short time and date packet: %zi",
+			msg->len);
+		return;
+	}
+
+	actual_year = 1985 + tdp->year;
+	actual_month = tdp->month;
+	actual_day = tdp->day * 0.25;
+	actual_hour = tdp->hours;
+	actual_minute = tdp->minutes;
+	actual_seconds = tdp->seconds * 0.25;
+
+	if (tdp->local_hour_offset == 125) {
+		snprintf(timezone_offset, sizeof(timezone_offset),
+			 "+00:00 (Local Time)");
+	} else 	if (!priv->utc) {
+		actual_hour += tdp->local_hour_offset;
+		actual_minute += tdp->local_minute_offset;
+
+		/* Wraparound for hours and minutes if needed */
+		if (actual_minute >= 60) {
+			actual_minute -= 60;
+			actual_hour++;
+		} else if (actual_minute < 0) {
+			actual_minute += 60;
+			actual_hour--;
+		}
+
+		if (actual_hour >= 24) {
+			actual_hour -= 24;
+			actual_day++;
+		} else if (actual_hour < 0) {
+			actual_hour += 24;
+			actual_day--;
+		}
+
+		snprintf(timezone_offset, sizeof(timezone_offset), "%+03d:%02d",
+			 tdp->local_hour_offset, abs(tdp->local_minute_offset));
+	} else {
+		snprintf(timezone_offset, sizeof(timezone_offset),
+			 "+00:00 (UTC)");
+	}
+
+	snprintf(time_buffer, sizeof(time_buffer),
+		 "%d-%02d-%02.0f %02d:%02d:%05.2f%.20s",
+		 actual_year, actual_month, actual_day, actual_hour,
+		 actual_minute, actual_seconds, timezone_offset);
+
+	printf("SA: 0x%02X, NAME:  0x%016llX, Time: %s\n",
+	       msg->peername.can_addr.j1939.addr,
+	       msg->peername.can_addr.j1939.name, time_buffer);
+
+	if (!priv->broadcast)
+		priv->done = true;
+}
+
+static int j1939_timedate_cli_rx_buf(struct j1939_timedate_cli_priv *priv,
+				     struct j1939_timedate_msg *msg)
+{
+	pgn_t pgn = msg->peername.can_addr.j1939.pgn;
+	int ret = 0;
+
+	switch (pgn) {
+	case J1939_PGN_TD:
+		print_time_date_packet(priv, msg);
+		break;
+	default:
+		pr_warn("%s: unsupported PGN: %x", __func__, pgn);
+		/* Not a critical error */
+		break;
+	}
+
+	return ret;
+}
+
+static int j1939_timedate_cli_rx_one(struct j1939_timedate_cli_priv *priv,
+				     int sock)
+{
+	struct j1939_timedate_msg *msg;
+	int flags = 0;
+	int ret;
+
+	msg = malloc(sizeof(*msg));
+	if (!msg) {
+		pr_err("can't allocate rx msg struct\n");
+		return -ENOMEM;
+	}
+	msg->buf_size = J1939_TIMEDATE_MAX_TRANSFER_LENGH;
+	msg->peer_addr_len = sizeof(msg->peername);
+	msg->sock = sock;
+
+	ret = recvfrom(sock, &msg->buf[0], msg->buf_size, flags,
+		       (struct sockaddr *)&msg->peername, &msg->peer_addr_len);
+
+	if (ret < 0) {
+		ret = -errno;
+		pr_warn("recvfrom() failed: %i %s", ret, strerror(-ret));
+		return ret;
+	}
+
+	if (ret < 3) {
+		pr_warn("received too short message: %i", ret);
+		return -EINVAL;
+	}
+
+	msg->len = ret;
+
+	ret = j1939_timedate_cli_rx_buf(priv, msg);
+	if (ret < 0) {
+		pr_warn("failed to process rx buf: %i (%s)\n", ret,
+			strerror(ret));
+		return ret;
+	}
+
+	return 0;
+}
+
+static int j1939_timedate_cli_handle_events(struct j1939_timedate_cli_priv *priv,
+					    unsigned int nfds)
+{
+	int ret;
+	unsigned int n;
+
+	for (n = 0; n < nfds && n < priv->cmn.epoll_events_size; ++n) {
+		struct epoll_event *ev = &priv->cmn.epoll_events[n];
+
+		if (!ev->events) {
+			warn("no events");
+			continue;
+		}
+
+		if (ev->events & POLLIN) {
+			ret = j1939_timedate_cli_rx_one(priv, ev->data.fd);
+			if (ret) {
+				warn("recv one");
+				return ret;
+			}
+		}
+	}
+	return 0;
+}
+
+static int j1939_timedate_cli_process_events_and_tasks(struct j1939_timedate_cli_priv *priv)
+{
+	int ret, nfds;
+
+	ret = libj1939_prepare_for_events(&priv->cmn, &nfds, false);
+	if (ret)
+		return ret;
+
+	if (nfds > 0) {
+		ret = j1939_timedate_cli_handle_events(priv, nfds);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
+
+static int j1939_timedate_cli_send_req(struct j1939_timedate_cli_priv *priv)
+{
+	struct sockaddr_can addr = priv->peername;
+	uint8_t data[3] = {0};
+	int ret;
+
+	addr.can_addr.j1939.pgn = J1939_PGN_REQUEST_PGN;
+
+	data[0] = J1939_PGN_TD & 0xff;
+	data[1] = (J1939_PGN_TD >> 8) & 0xff;
+	data[2] = (J1939_PGN_TD >> 16) & 0xff;
+
+	ret = sendto(priv->sock_main, data, sizeof(data), 0,
+		     (struct sockaddr *)&addr, sizeof(addr));
+	if (ret == -1) {
+		ret = -errno;
+		pr_warn("failed to send data: %i (%s)", ret, strerror(ret));
+		return ret;
+	}
+
+	return 0;
+}
+
+static int j1939_timedate_cli_sock_main_prepare(struct j1939_timedate_cli_priv *priv)
+{
+	struct sockaddr_can addr = priv->sockname;
+	int ret;
+
+	ret = libj1939_open_socket();
+	if (ret < 0)
+		return ret;
+
+	priv->sock_main = ret;
+
+	ret = libj1939_bind_socket(priv->sock_main, &addr);
+	if (ret < 0)
+		return ret;
+
+	ret = libj1939_socket_prio(priv->sock_main,
+					J1939_TIMEDATE_PRIO_DEFAULT);
+	if (ret < 0)
+		return ret;
+
+	ret = libj1939_set_broadcast(priv->sock_main);
+	if (ret < 0)
+		return ret;
+
+	return libj1939_add_socket_to_epoll(priv->cmn.epoll_fd,
+						priv->sock_main, EPOLLIN);
+}
+
+static int j1939_timedate_cli_sock_nack_prepare(struct j1939_timedate_cli_priv *priv)
+{
+	struct sockaddr_can addr = priv->sockname;
+	int ret;
+
+	ret = libj1939_open_socket();
+	if (ret < 0)
+		return ret;
+
+	priv->sock_nack = ret;
+
+	addr.can_addr.j1939.pgn = ISOBUS_PGN_ACK;
+	ret = libj1939_bind_socket(priv->sock_nack, &addr);
+	if (ret < 0)
+		return ret;
+
+	return libj1939_add_socket_to_epoll(priv->cmn.epoll_fd,
+						priv->sock_nack, EPOLLIN);
+}
+
+static int j1939_timedate_cli_sock_prepare(struct j1939_timedate_cli_priv *priv)
+{
+	int ret;
+
+	ret = libj1939_create_epoll();
+	if (ret < 0)
+		return ret;
+
+	priv->cmn.epoll_fd = ret;
+
+	priv->cmn.epoll_events = calloc(J1939_TIMEDATE_CLI_MAX_EPOLL_EVENTS,
+					sizeof(struct epoll_event));
+	if (!priv->cmn.epoll_events)
+		return -ENOMEM;
+
+	priv->cmn.epoll_events_size = J1939_TIMEDATE_CLI_MAX_EPOLL_EVENTS;
+
+	ret = j1939_timedate_cli_sock_main_prepare(priv);
+	if (ret < 0)
+		return ret;
+
+	return j1939_timedate_cli_sock_nack_prepare(priv);
+}
+
+static void j1939_timedate_cli_print_help(void)
+{
+	printf("Usage: j1939_timedate-cli [options]\n");
+	printf("Options:\n");
+	printf("  --interface <interface_name> or -i <interface_name>\n");
+	printf("	  Specifies the CAN interface to use (mandatory).\n");
+	printf("  --local-address <local_address_hex> or -a <local_address_hex>\n");
+	printf("	  Specifies the local address in hexadecimal (mandatory if local name is not provided).\n");
+	printf("  --local-name <local_name_hex> or -n <local_name_hex>\n");
+	printf("	  Specifies the local NAME in hexadecimal (mandatory if local address is not provided).\n");
+	printf("  --remote-address <remote_address_hex> or -r <remote_address_hex>\n");
+	printf("	  Specifies the remote address in hexadecimal (optional).\n");
+	printf("  --remote-name <remote_name_hex> or -m <remote_name_hex>\n");
+	printf("	  Specifies the remote NAME in hexadecimal (optional).\n");
+	printf("  --utc or -u\n");
+	printf("	  Outputs the time in UTC format.\n");
+	printf("\n");
+	printf("Note:\n");
+	printf("  Local address and local name are mutually exclusive and one must be provided.\n");
+	printf("  Remote address and remote name are mutually exclusive. \n");
+	printf("  If no remote property is provided, the broadcast address will be used.\n");
+	printf("\n");
+	printf("Behavior:\n");
+	printf("  In unicast mode (remote address or remote name provided),\n");
+	printf("  the client will send a request and wait for the first response, then exit.\n");
+	printf("  In broadcast mode (no remote address or remote name provided),\n");
+	printf("  the program will wait 1000 milliseconds to collect responses, then exit.\n");
+	printf("\n");
+	printf("Time Output Formats:\n");
+	printf("  YYYY-MM-DD HH:MM:SS.SS+00:00 (Local Time) - when no time zone information is received.\n");
+	printf("  YYYY-MM-DD HH:MM:SS.SS+00:00 (UTC) - when the --utc option is used.\n");
+	printf("  YYYY-MM-DD HH:MM:SS.SS+00:00 - default response with time zone offset automatically calculated.\n");
+	printf("\n");
+	printf("Complete Message Format:\n");
+	printf("  The message will include the Source Address (SA) and J1939 NAME, formatted as follows:\n");
+	printf("  SA: 0x60, NAME: 0x0000000000000000, Time: 2024-05-16 20:23:40.00+02:00\n");
+	printf("  If the NAME is known, it will have a non-zero value.\n");
+	printf("\n");
+	printf("Usage Examples:\n");
+	printf("  j1939acd -r 64-95 -c /tmp/1122334455667788.jacd 1122334455667788 vcan0 &\n");
+	printf("\n");
+	printf("  Broadcast mode:\n");
+	printf("    j1939-timedate-cli -i vcan0 -a 0x80\n");
+	printf("\n");
+	printf("  Unicast mode:\n");
+	printf("    j1939-timedate-cli -i vcan0 -a 0x80 -r 0x90\n");
+	printf("\n");
+	printf("  Using NAMEs instead of addresses:\n");
+	printf("    j1939acd -r 64-95 -c /tmp/1122334455667788.jacd 1122334455667788 vcan0 &\n");
+	printf("    j1939-timedate-cli -i vcan0 -n 0x1122334455667788\n");
+}
+
+static int j1939_timedate_cli_parse_args(struct j1939_timedate_cli_priv *priv, int argc, char *argv[])
+{
+	struct sockaddr_can *remote = &priv->peername;
+	struct sockaddr_can *local = &priv->sockname;
+	bool local_address_set = false;
+	bool local_name_set = false;
+	bool remote_address_set = false;
+	bool remote_name_set = false;
+	bool interface_set = false;
+	int long_index = 0;
+	int opt;
+
+	static struct option long_options[] = {
+		{"interface", required_argument, 0, 'i'},
+		{"local-address", required_argument, 0, 'a'},
+		{"local-name", required_argument, 0, 'n'},
+		{"remote-address", required_argument, 0, 'r'},
+		{"remote-name", required_argument, 0, 'm'},
+		{"utc", no_argument, 0, 'u'},
+		{0, 0, 0, 0}
+	};
+
+	while ((opt = getopt_long(argc, argv, "a:n:r:m:i:u", long_options, &long_index)) != -1) {
+		switch (opt) {
+		case 'a':
+			local->can_addr.j1939.addr = strtoul(optarg, NULL, 16);
+			local_address_set = true;
+			break;
+		case 'n':
+			local->can_addr.j1939.name = strtoull(optarg, NULL, 16);
+			local_name_set = true;
+			break;
+		case 'r':
+			remote->can_addr.j1939.addr = strtoul(optarg, NULL, 16);
+			remote_address_set = true;
+			break;
+		case 'm':
+			remote->can_addr.j1939.name = strtoull(optarg, NULL, 16);
+			remote_name_set = true;
+			break;
+		case 'i':
+			local->can_ifindex = if_nametoindex(optarg);
+			if (!local->can_ifindex) {
+				pr_err("Interface %s not found. Error: %d (%s)\n",
+				       optarg, errno, strerror(errno));
+				return -EINVAL;
+			}
+			remote->can_ifindex = local->can_ifindex;
+			interface_set = true;
+			break;
+		case 'u':
+			priv->utc = true;
+			break;
+		default:
+			j1939_timedate_cli_print_help();
+			return -EINVAL;
+		}
+	}
+
+	if (!interface_set) {
+		pr_err("interface not specified");
+		j1939_timedate_cli_print_help();
+		return -EINVAL;
+	}
+
+	if ((local_address_set && local_name_set) ||
+	    (remote_address_set && remote_name_set)) {
+		pr_err("Local address and local name or remote address and remote name are mutually exclusive\n");
+		j1939_timedate_cli_print_help();
+		return -EINVAL;
+	}
+
+	if (!local_address_set && !local_name_set) {
+		pr_err("Local address and local name not specified. One of them is required\n");
+		j1939_timedate_cli_print_help();
+		return -EINVAL;
+	}
+
+	/* If no remote address is set, set it to broadcast */
+	if (!remote_address_set && !remote_name_set) {
+		remote->can_addr.j1939.addr = J1939_NO_ADDR;
+		priv->broadcast = true;
+	}
+
+	return 0;
+}
+
+int main(int argc, char *argv[])
+{
+	struct j1939_timedate_cli_priv *priv;
+	struct timespec ts;
+	int64_t time_diff;
+	int ret;
+
+	priv = malloc(sizeof(*priv));
+	if (!priv)
+		err(EXIT_FAILURE, "can't allocate priv");
+
+	bzero(priv, sizeof(*priv));
+
+	libj1939_init_sockaddr_can(&priv->sockname, J1939_PGN_TD);
+	libj1939_init_sockaddr_can(&priv->peername, J1939_PGN_REQUEST_PGN);
+
+	ret = j1939_timedate_cli_parse_args(priv, argc, argv);
+	if (ret)
+		return ret;
+
+	ret = j1939_timedate_cli_sock_prepare(priv);
+	if (ret)
+		return ret;
+
+	clock_gettime(CLOCK_MONOTONIC, &ts);
+	priv->cmn.next_send_time = ts;
+	priv->wait_until_time = priv->cmn.next_send_time;
+	/* Wait one second to collect all responses by default */
+	timespec_add_ms(&priv->wait_until_time, 1000);
+
+	ret = j1939_timedate_cli_send_req(priv);
+	if (ret)
+		return ret;
+
+	while (1) {
+		ret = j1939_timedate_cli_process_events_and_tasks(priv);
+		if (ret)
+			break;
+
+		if (priv->done)
+			break;
+
+		clock_gettime(CLOCK_MONOTONIC, &ts);
+		time_diff = timespec_diff_ms(&priv->wait_until_time, &ts);
+		if (time_diff < 0)
+			break;
+	}
+
+	close(priv->cmn.epoll_fd);
+	free(priv->cmn.epoll_events);
+
+	close(priv->sock_main);
+	close(priv->sock_nack);
+
+	return ret;
+}
+
--- a/j1939_timedate/j1939_timedate_cmn.h
+++ b/j1939_timedate/j1939_timedate_cmn.h
@ -0,0 +1,84 @@
+// SPDX-License-Identifier: LGPL-2.0-only
+// SPDX-FileCopyrightText: 2024 Oleksij Rempel <linux@rempel-privat.de>
+
+#ifndef _J1939_TIMEDATE_H_
+#define _J1939_TIMEDATE_H_
+
+#include <stdint.h>
+#include <endian.h>
+#include <stdbool.h>
+#include <sys/epoll.h>
+
+#include <linux/can.h>
+#include <linux/kernel.h>
+#include "../libj1939.h"
+#include "../lib.h"
+
+/* SAE J1939-71:2002 - 5.3 pgn54528 - Time/Date Adjust - TDA - */
+#define J1939_PGN_TDA				0x0d500 /* 54528 */
+/* SAE J1939-71:2002 - 5.3 pgn65254 - Time/Date - TD - */
+#define J1939_PGN_TD				0x0fee6 /* 65254 */
+
+#define J1939_PGN_REQUEST_PGN			0x0ea00 /* 59904 */
+
+/* ISO 11783-3:2018 - 5.4.5 Acknowledgment */
+#define ISOBUS_PGN_ACK				0x0e800 /* 59392 */
+
+#define J1939_TIMEDATE_PRIO_DEFAULT		6
+
+#define J1939_TIMEDATE_MAX_TRANSFER_LENGH	8
+
+struct j1939_timedate_stats {
+	int err;
+	uint32_t tskey_sch;
+	uint32_t tskey_ack;
+	uint32_t send;
+};
+
+struct j1939_timedate_msg {
+	uint8_t buf[J1939_TIMEDATE_MAX_TRANSFER_LENGH];
+	size_t buf_size;
+	ssize_t len; /* length of received message */
+	struct sockaddr_can peername;
+	socklen_t peer_addr_len;
+	int sock;
+};
+
+struct j1939_timedate_err_msg {
+	struct sock_extended_err *serr;
+	struct scm_timestamping *tss;
+	struct j1939_timedate_stats *stats;
+};
+
+/*
+ * struct time_date_packet - Represents the PGN 65254 Time/Date packet
+ *
+ * @seconds: Seconds since the last minute (0-59) with a scaling factor,
+ *           meaning each increment represents 0.25 seconds.
+ * @minutes: Minutes since the last hour (0-59) with no scaling.
+ * @hours: Hours since midnight (0-23) with no scaling.
+ * @month: Current month (1-12) with no scaling.
+ * @day: Day of the month with a scaling factor, each increment represents 0.25
+ *       day.
+ * @year: Year offset since 1985, each increment represents one year.
+ * @local_minute_offset: Offset in minutes from UTC, can range from -125 to 125
+ *                       minutes.
+ * @local_hour_offset: Offset in hours from UTC, can range from -125 to 125
+ *                     hours.
+ *
+ * This structure defines each component of the Time/Date as described in
+ * PGN 65254, using each byte to represent different components of the standard
+ * UTC time and optionally adjusted local time based on offsets.
+ */
+struct j1939_time_date_packet {
+	uint8_t seconds;
+	uint8_t minutes;
+	uint8_t hours;
+	uint8_t month;
+	uint8_t day;
+	uint8_t year;
+	int8_t local_minute_offset;
+	int8_t local_hour_offset;
+};
+
+#endif /* !_J1939_TIMEDATE_H_ */
--- a/j1939_timedate/j1939_timedate_srv.c
+++ b/j1939_timedate/j1939_timedate_srv.c
@ -0,0 +1,450 @@
+// SPDX-License-Identifier: LGPL-2.0-only
+// SPDX-FileCopyrightText: 2024 Oleksij Rempel <linux@rempel-privat.de>
+
+#include <err.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <linux/kernel.h>
+#include <net/if.h>
+#include <poll.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "j1939_timedate_cmn.h"
+
+#define J1939_TIMEDATE_SRV_MAX_EPOLL_EVENTS	10
+
+struct j1939_timedate_srv_priv {
+	int sock_nack;
+	int sock_main;
+
+	struct sockaddr_can sockname;
+
+	struct j1939_timedate_stats stats;
+
+	struct libj1939_cmn cmn;
+};
+
+static void gmtime_to_j1939_pgn_65254_td(struct j1939_time_date_packet *tdp)
+{
+	struct tm utc_tm_buf, local_tm_buf;
+	int hour_offset, minute_offset;
+	struct tm *utc_tm, *local_tm;
+	int year_since_1985;
+	time_t now;
+
+	now = time(NULL);
+	utc_tm = gmtime_r(&now, &utc_tm_buf);
+	local_tm = localtime_r(&now, &local_tm_buf);
+
+	/* Calculate the offsets */
+	hour_offset = local_tm->tm_hour - utc_tm->tm_hour;
+	minute_offset = local_tm->tm_min - utc_tm->tm_min;
+
+	/* Handle date rollover */
+	if (local_tm->tm_mday != utc_tm->tm_mday) {
+		if (local_tm->tm_hour < 12)
+			hour_offset += 24;  /* past midnight */
+		else
+			hour_offset -= 24;  /* before midnight */
+	}
+
+	/*
+	 * Seconds (spn959):
+	 *  Resolution: 0.25 /bit, 0 offset
+	 *  Data Range: 0 to 250 (0 to 62.5 seconds)
+	 *  Operational Range: 0 to 239 (0 to 59.75 seconds)
+	 */ 
+	tdp->seconds = (uint8_t)(utc_tm->tm_sec / 0.25);
+	if (tdp->seconds > 239)
+		tdp->seconds = 239;
+
+	/*
+	 * Minutes (spn960):
+	 *  Resolution: 1 min/bit, 0 offset
+	 *  Data Range: 0 to 250 (0 to 250 minutes)
+	 *  Operational Range: 0 to 59 (0 to 59 minutes)
+	 */
+	tdp->minutes = (uint8_t)utc_tm->tm_min;
+	if (tdp->minutes > 59)
+		tdp->minutes = 59;
+
+	/*
+	 * Hours (spn961):
+	 *  Resolution: 1 hr/bit, 0 offset
+	 *  Data Range: 0 to 250 (0 to 250 hours)
+	 *  Operational Range: 0 to 23 (0 to 23 hours)
+	 */
+	tdp->hours = (uint8_t)utc_tm->tm_hour;
+	if (tdp->hours > 23)
+		tdp->hours = 23;
+
+	/*
+	 * Day (spn962):
+	 * Resolution: 0.25 /bit, 0 offset
+	 * Data Range: 0 to 250 (0 to 62.5 days)
+	 * Operational Range: 1 to 127 (0.25 to 31.75 days)
+	 */
+	tdp->day = (uint8_t)(utc_tm->tm_mday / 0.25);
+	if (tdp->day < 1 || tdp->day > 127)
+		tdp->day = 1;
+
+	/*
+	 * Month (spn963):
+	 * Resolution: 1 month/bit, 0 offset
+	 * Data Range: 0 to 250 (0 to 250 months)
+	 * Operational Range: 1 to 12 (1 to 12 months)
+	 */
+	tdp->month = (uint8_t)(utc_tm->tm_mon + 1);
+	if (tdp->month < 1 || tdp->month > 12)
+		tdp->month = 1;
+
+	/*
+	 * Year (spn964):
+	 * Resolution: 1 year/bit, 1985 offset
+	 * Data Range: 0 to 250 (1985 to 2235)
+	 * Operational Range: 0 to 250 (1985 to 2235)
+	 */
+	year_since_1985 = utc_tm->tm_year - 85;
+	if (year_since_1985 < 0) {
+		/* Fallback to year 1985 if year is before 1985 */
+		tdp->year = 0;
+	} else if (year_since_1985 > 250) {
+		/* Fallback to year 2235 if year is beyond 2235 */
+		tdp->year = 250;
+	} else {
+		tdp->year = (uint8_t)year_since_1985;
+	}
+
+	/*
+	 * Local minute offset (spn1601):
+	 * Resolution: 1 min/bit, -125 offset
+	 * Data Range: -125 to 125 minutes
+	 * Operational Range: -59 to 59 minutes
+	 */
+	tdp->local_minute_offset = (int8_t)minute_offset;
+
+	/*
+	 * Local hour offset (spn1602):
+	 * Resolution: 1 hr/bit, -125 offset
+	 * Data Range: -125 to +125 hours
+	 * Operational Range: -24 to +23 hours
+	 * Note: If the local hour offset parameter is  equal to 125 (0xFA),
+	 * the local time then the time parameter is the local time instead of
+	 * UTC.
+	 */
+	tdp->local_hour_offset = (int8_t)hour_offset;
+}
+
+static int j1939_timedate_srv_send_res(struct j1939_timedate_srv_priv *priv,
+				       struct sockaddr_can *addr)
+{
+	struct sockaddr_can peername = *addr;
+	struct j1939_time_date_packet tdp;
+	int ret;
+
+	gmtime_to_j1939_pgn_65254_td(&tdp);
+
+	peername.can_addr.j1939.pgn = J1939_PGN_TD;
+	ret = sendto(priv->sock_main, &tdp, sizeof(tdp), 0,
+		     (struct sockaddr *)&peername, sizeof(peername));
+	if (ret == -1) {
+		ret = -errno;
+		pr_warn("failed to send data: %i (%s)", ret, strerror(ret));
+		return ret;
+	}
+
+	return 0;
+}
+
+// check if the received message is a request for the time and date
+static int j1939_timedate_srv_process_request(struct j1939_timedate_srv_priv *priv,
+					       struct j1939_timedate_msg *msg)
+{
+
+	if (msg->buf[0] != (J1939_PGN_TD & 0xff) ||
+	    msg->buf[1] != ((J1939_PGN_TD >> 8) & 0xff) ||
+	    msg->buf[2] != ((J1939_PGN_TD >> 16) & 0xff)) {
+		/* Don't care, not a time and date request */
+		return 0;
+	}
+
+	return j1939_timedate_srv_send_res(priv, &msg->peername);
+}
+
+static int j1939_timedate_srv_rx_buf(struct j1939_timedate_srv_priv *priv, struct j1939_timedate_msg *msg)
+{
+	pgn_t pgn = msg->peername.can_addr.j1939.pgn;
+	int ret = 0;
+
+	switch (pgn) {
+	case J1939_PGN_REQUEST_PGN:
+		ret = j1939_timedate_srv_process_request(priv, msg);
+		break;
+	default:
+		pr_warn("%s: unsupported PGN: %x", __func__, pgn);
+		/* Not a critical error */
+		break;
+	}
+
+	return ret;
+}
+
+static int j1939_timedate_srv_rx_one(struct j1939_timedate_srv_priv *priv, int sock)
+{
+	struct j1939_timedate_msg *msg;
+	int flags = 0;
+	int ret;
+
+	msg = malloc(sizeof(*msg));
+	if (!msg) {
+		pr_err("can't allocate rx msg struct\n");
+		return -ENOMEM;
+	}
+	msg->buf_size = J1939_TIMEDATE_MAX_TRANSFER_LENGH;
+	msg->peer_addr_len = sizeof(msg->peername);
+	msg->sock = sock;
+
+	ret = recvfrom(sock, &msg->buf[0], msg->buf_size, flags,
+		       (struct sockaddr *)&msg->peername, &msg->peer_addr_len);
+
+	if (ret < 0) {
+		ret = -errno;
+		pr_warn("recvfrom() failed: %i %s", ret, strerror(-ret));
+		return ret;
+	}
+
+	if (ret < 3) {
+		pr_warn("received too short message: %i", ret);
+		return -EINVAL;
+	}
+
+	msg->len = ret;
+
+	ret = j1939_timedate_srv_rx_buf(priv, msg);
+	if (ret < 0) {
+		pr_warn("failed to process rx buf: %i (%s)\n", ret,
+			strerror(ret));
+		return ret;
+	}
+
+	return 0;
+}
+
+static int j1939_timedate_srv_handle_events(struct j1939_timedate_srv_priv *priv,
+					    unsigned int nfds)
+{
+	int ret;
+	unsigned int n;
+
+	for (n = 0; n < nfds && n < priv->cmn.epoll_events_size; ++n) {
+		struct epoll_event *ev = &priv->cmn.epoll_events[n];
+
+		if (!ev->events) {
+			warn("no events");
+			continue;
+		}
+
+		if (ev->events & POLLIN) {
+			ret = j1939_timedate_srv_rx_one(priv, ev->data.fd);
+			if (ret) {
+				warn("recv one");
+				return ret;
+			}
+		}
+	}
+	return 0;
+}
+
+static int j1939_timedate_srv_process_events_and_tasks(struct j1939_timedate_srv_priv *priv)
+{
+	int ret, nfds;
+
+	ret = libj1939_prepare_for_events(&priv->cmn, &nfds, false);
+	if (ret)
+		return ret;
+
+	if (nfds > 0) {
+		ret = j1939_timedate_srv_handle_events(priv, nfds);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
+
+static int j1939_timedate_srv_sock_main_prepare(struct j1939_timedate_srv_priv *priv)
+{
+	struct sockaddr_can addr = priv->sockname;
+	int ret;
+
+	ret = libj1939_open_socket();
+	if (ret < 0)
+		return ret;
+
+	priv->sock_main = ret;
+
+	ret = libj1939_bind_socket(priv->sock_main, &addr);
+	if (ret < 0)
+		return ret;
+
+	ret = libj1939_socket_prio(priv->sock_main,
+				   J1939_TIMEDATE_PRIO_DEFAULT);
+	if (ret < 0)
+		return ret;
+
+	ret = libj1939_set_broadcast(priv->sock_main);
+	if (ret < 0)
+		return ret;
+
+
+	return libj1939_add_socket_to_epoll(priv->cmn.epoll_fd,
+						priv->sock_main, EPOLLIN);
+}
+
+static int j1939_timedate_srv_sock_prepare(struct j1939_timedate_srv_priv *priv)
+{
+	int ret;
+
+	ret = libj1939_create_epoll();
+	if (ret < 0)
+		return ret;
+
+	priv->cmn.epoll_fd = ret;
+
+	priv->cmn.epoll_events = calloc(J1939_TIMEDATE_SRV_MAX_EPOLL_EVENTS,
+					sizeof(struct epoll_event));
+	if (!priv->cmn.epoll_events)
+		return -ENOMEM;
+
+	priv->cmn.epoll_events_size = J1939_TIMEDATE_SRV_MAX_EPOLL_EVENTS;
+
+	return j1939_timedate_srv_sock_main_prepare(priv);
+}
+
+static void j1939_timedate_srv_print_help(void)
+{
+	printf("Usage: j1939-timedate-srv [options]\n");
+	printf("Options:\n");
+	printf("  --interface <interface_name> or -i <interface_name>\n");
+	printf("      Specifies the CAN interface to use (mandatory).\n");
+	printf("  --local-address <local_address_hex> or -a <local_address_hex>\n");
+	printf("      Specifies the local address in hexadecimal (mandatory if\n");
+	printf("      local name is not provided).\n");
+	printf("  --local-name <local_name_hex> or -n <local_name_hex>\n");
+	printf("      Specifies the local NAME in hexadecimal (mandatory if\n");
+	printf("      local address is not provided).\n");
+	printf("\n");
+	printf("Note: Local address and local name are mutually exclusive and one\n");
+	printf("      must be provided.\n");
+	printf("\n");
+	printf("Usage Examples:\n");
+	printf("  Using local address:\n");
+	printf("    j1939-timedate-srv -i vcan0 -a 0x90\n");
+	printf("\n");
+	printf("  Using local NAME:\n");
+	printf("    j1939acd -r 64-95 -c /tmp/1122334455667789.jacd 1122334455667789 vcan0 &\n");
+	printf("    j1939-timedate-srv -i vcan0 -n 0x1122334455667789\n");
+}
+
+static int j1939_timedate_srv_parse_args(struct j1939_timedate_srv_priv *priv,
+					 int argc, char *argv[])
+{
+	struct sockaddr_can *local = &priv->sockname;
+	bool local_address_set = false;
+	bool local_name_set = false;
+	bool interface_set = false;
+	int long_index = 0;
+	int opt;
+
+	static struct option long_options[] = {
+		{"interface", required_argument, 0, 'i'},
+		{"local-address", required_argument, 0, 'a'},
+		{"local-name", required_argument, 0, 'n'},
+		{0, 0, 0, 0}
+	};
+
+	while ((opt = getopt_long(argc, argv, "a:n:i:", long_options, &long_index)) != -1) {
+		switch (opt) {
+		case 'a':
+			local->can_addr.j1939.addr = strtoul(optarg, NULL, 16);
+			local_address_set = true;
+			break;
+		case 'n':
+			local->can_addr.j1939.name = strtoull(optarg, NULL, 16);
+			local_name_set = true;
+			break;
+		case 'i':
+			local->can_ifindex = if_nametoindex(optarg);
+			if (!local->can_ifindex) {
+				pr_err("Interface %s not found. Error: %d (%s)\n",
+				       optarg, errno, strerror(errno));
+				return -EINVAL;
+			}
+			interface_set = true;
+			break;
+		default:
+			j1939_timedate_srv_print_help();
+			return -EINVAL;
+		}
+	}
+
+	if (!interface_set) {
+		pr_err("interface not specified");
+		j1939_timedate_srv_print_help();
+		return -EINVAL;
+	}
+
+	if (local_address_set && local_name_set) {
+		pr_err("local address and local name or remote address and remote name are mutually exclusive");
+		j1939_timedate_srv_print_help();
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+int main(int argc, char *argv[])
+{
+	struct j1939_timedate_srv_priv *priv;
+	struct timespec ts;
+	int ret;
+
+	priv = malloc(sizeof(*priv));
+	if (!priv)
+		err(EXIT_FAILURE, "can't allocate priv");
+
+	bzero(priv, sizeof(*priv));
+
+	libj1939_init_sockaddr_can(&priv->sockname, J1939_PGN_REQUEST_PGN);
+
+	ret = j1939_timedate_srv_parse_args(priv, argc, argv);
+	if (ret)
+		return ret;
+
+	clock_gettime(CLOCK_MONOTONIC, &ts);
+	priv->cmn.next_send_time = ts;
+
+	ret = j1939_timedate_srv_sock_prepare(priv);
+	if (ret)
+		return ret;
+
+	while (1) {
+		ret = j1939_timedate_srv_process_events_and_tasks(priv);
+		if (ret)
+			break;
+	}
+
+	close(priv->cmn.epoll_fd);
+	free(priv->cmn.epoll_events);
+
+	close(priv->sock_main);
+	close(priv->sock_nack);
+
+	return ret;
+}
+
--- a/j1939acd.c
+++ b/j1939acd.c
@ -38,7 +38,6 @@ static const char help_msg[] =
 	"			e.g. 80,50-100,200-210 (defaults to 0-253)" "\n"
 	"  -c, --cache=FILE	Cache file to save/restore the source address" "\n"
 	"  -a, --address=ADDRESS	Start with Source Address ADDRESS" "\n"
-	"  -p, --prefix=STR	Prefix to use when logging" "\n"
 	"\n"
 	"NAME is the 64bit nodename" "\n"
 	"\n"
@ -54,14 +53,13 @@ static struct option long_opts[] = {
 	{ "range", required_argument, NULL, 'r', },
 	{ "cache", required_argument, NULL, 'c', },
 	{ "address", required_argument, NULL, 'a', },
-	{ "prefix", required_argument, NULL, 'p', },
 	{ },
 };
 #else
 #define getopt_long(argc, argv, optstring, longopts, longindex) \
 	getopt((argc), (argv), (optstring))
 #endif
-static const char optstring[] = "vr:c:a:p:?";
+static const char optstring[] = "vr:c:a:?";

 /* byte swap functions */
 static inline int host_is_little_endian(void)
@ -466,9 +464,6 @@ int main(int argc, char *argv[])
 	struct sockaddr_can saddr;
 	uint64_t cmd_name;

-#ifdef _GNU_SOURCE
-	program_invocation_name = program_invocation_short_name;
-#endif
 	/* argument parsing */
 	while ((opt = getopt_long(argc, argv, optstring, long_opts, NULL)) != -1)
 		switch (opt) {
@ -484,15 +479,6 @@ int main(int argc, char *argv[])
 		case 'a':
 			s.current_sa = strtoul(optarg, 0, 0);
 			break;
-		case 'p':
-#ifdef _GNU_SOURCE
-			if (asprintf(&program_invocation_name, "%s.%s",
-				     program_invocation_short_name, optarg) < 0)
-				err(1, "asprintf(program invocation name)");
-#else
-			err(0, "compile with -D_GNU_SOURCE to use -p");
-#endif
-			break;
 		default:
 			fputs(help_msg, stderr);
 			exit(1);
--- a/j1939cat.c
+++ b/j1939cat.c
@ -97,15 +97,6 @@ static const char help_msg[] =

 static const char optstring[] = "?hi:vs:rp:P:R:B";

-
-static void j1939cat_init_sockaddr_can(struct sockaddr_can *sac)
-{
-	sac->can_family = AF_CAN;
-	sac->can_addr.j1939.addr = J1939_NO_ADDR;
-	sac->can_addr.j1939.name = J1939_NO_NAME;
-	sac->can_addr.j1939.pgn = J1939_NO_PGN;
-}
-
 static ssize_t j1939cat_send_one(struct j1939cat_priv *priv, int out_fd,
 			     const void *buf, size_t buf_size)
 {
@ -766,8 +757,8 @@ int main(int argc, char *argv[])
 	priv->polltimeout = 100000;
 	priv->repeat = 1;

-	j1939cat_init_sockaddr_can(&priv->sockname);
-	j1939cat_init_sockaddr_can(&priv->peername);
+	libj1939_init_sockaddr_can(&priv->sockname, J1939_NO_PGN);
+	libj1939_init_sockaddr_can(&priv->peername, J1939_NO_PGN);

 	ret = j1939cat_parse_args(priv, argc, argv);
 	if (ret)
--- a/j1939sr.c
+++ b/j1939sr.c
@ -94,9 +94,6 @@ int main(int argc, char **argv)
 	struct pollfd pfd[2];
 	uint8_t *buf;

-#ifdef _GNU_SOURCE
-	program_invocation_name = program_invocation_short_name;
-#endif
 	/* argument parsing */
 	while ((opt = getopt_long(argc, argv, optstring, long_opts, NULL)) != -1)
 		switch (opt) {
--- a/libj1939.c
+++ b/libj1939.c
@ -11,19 +11,24 @@
 */

 #include <err.h>
+#include <errno.h>
+#include <fcntl.h>
 #include <inttypes.h>
+#include <limits.h>
+#include <linux/kernel.h>
+#include <net/if.h>
+#include <net/if.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-
-#include <fcntl.h>
-#include <net/if.h>
+#include <sys/epoll.h>
 #include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <time.h>
 #include <unistd.h>

-#include <net/if.h>
-
 #include "libj1939.h"
+#include "lib.h"

 /* static data */
 static struct if_nameindex *saved;
@ -195,3 +200,232 @@ const char *libj1939_addr2str(const struct sockaddr_can *can)
 	return buf;
 }

+void libj1939_init_sockaddr_can(struct sockaddr_can *sac, uint32_t pgn)
+{
+	sac->can_family = AF_CAN;
+	sac->can_addr.j1939.addr = J1939_NO_ADDR;
+	sac->can_addr.j1939.name = J1939_NO_NAME;
+	sac->can_addr.j1939.pgn = pgn;
+}
+
+/**
+ * libj1939_open_socket - Open a new J1939 socket
+ *
+ * This function opens a new J1939 socket.
+ *
+ * Return: The file descriptor of the new socket, or a negative error code.
+ */
+int libj1939_open_socket(void)
+{
+	int ret;
+
+	/* Create a new CAN J1939 socket */
+	ret = socket(PF_CAN, SOCK_DGRAM, CAN_J1939);
+	if (ret < 0) {
+		/* Get the error code and print an error message */
+		ret = -errno;
+		pr_err("socket(j1939): %d (%s)", ret, strerror(ret));
+		return ret;
+	}
+	return ret;
+}
+
+/**
+ * libj1939_bind_socket - Bind a J1939 socket to a specific address
+ * @sock: The file descriptor of the socket
+ * @addr: The address to bind to
+ *
+ * This function binds a J1939 socket to a specific address.
+ *
+ * Return: 0 on success, or a negative error code.
+ */
+int libj1939_bind_socket(int sock, struct sockaddr_can *addr)
+{
+	int ret;
+
+	ret = bind(sock, (void *)addr, sizeof(*addr));
+	if (ret < 0) {
+		ret = -errno;
+		pr_err("failed to bind: %d (%s)", ret, strerror(ret));
+		return ret;
+	}
+
+	return 0;
+}
+
+/**
+ * libj1939_socket_prio - Set the priority of a J1939 socket
+ * @sock: The file descriptor of the socket
+ * @prio: The priority to set
+ *
+ * This function sets the priority of a J1939 socket.
+ *
+ * Return: 0 on success, or a negative error code.
+ */
+int libj1939_socket_prio(int sock, int prio)
+{
+	int ret;
+
+	ret = setsockopt(sock, SOL_CAN_J1939, SO_J1939_SEND_PRIO,
+			 &prio, sizeof(prio));
+	if (ret < 0) {
+		ret = -errno;
+		pr_warn("Failed to set priority %i. Error %i (%s)", prio, ret,
+			strerror(ret));
+		return ret;
+	}
+
+	return 0;
+}
+
+/**
+ * libj1939_set_broadcast - Enable broadcast on a J1939 socket
+ * @sock: The file descriptor of the socket
+ *
+ * This function enables broadcast on a J1939 socket.
+ *
+ * Return: 0 on success, or a negative error code.
+ */
+int libj1939_set_broadcast(int sock)
+{
+	int broadcast = true;
+	int ret;
+
+	ret = setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &broadcast,
+			 sizeof(broadcast));
+	if (ret < 0) {
+		ret = -errno;
+		pr_err("setsockopt(SO_BROADCAST): %d (%s)", ret, strerror(ret));
+		return ret;
+	}
+
+	return 0;
+}
+
+/**
+ * libj1939_add_socket_to_epoll - Add a socket to an epoll instance
+ * @epoll_fd: The file descriptor of the epoll instance
+ * @sock: The file descriptor of the socket
+ * @events: The events to monitor
+ *
+ * This function adds a socket to an epoll instance.
+ *
+ * Return: 0 on success, or a negative error code.
+ */
+int libj1939_add_socket_to_epoll(int epoll_fd, int sock, uint32_t events)
+{
+	struct epoll_event ev = {0};
+	int ret;
+
+	ev.events = events;
+	ev.data.fd = sock;
+
+	ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sock, &ev);
+	if (ret < 0) {
+		ret = errno;
+		pr_err("epoll_ctl(EPOLL_CTL_ADD): %d (%s)", ret, strerror(ret));
+		return ret;
+	}
+
+	return 0;
+}
+
+/**
+ * libj1939_create_epoll - Create a new epoll instance
+ *
+ * This function creates a new epoll instance.
+ *
+ * Return: The file descriptor of the new epoll instance, or a negative error
+ * code.
+ */
+int libj1939_create_epoll(void)
+{
+	int ret, epoll_fd;
+
+	epoll_fd = epoll_create1(0);
+	if (epoll_fd < 0) {
+		ret = -errno;
+		pr_err("epoll_create1: %d (%s)", ret, strerror(ret));
+		return ret;
+	}
+
+	return epoll_fd;
+}
+
+/**
+ * libj1939_get_timeout_ms - Get the timeout in milliseconds until a specific
+ *			     time
+ * @ts: The time to wait for
+ * @return: The timeout in milliseconds until the specified time
+ *
+ * This function calculates the timeout in milliseconds until a specific time.
+ *
+ * Return: The timeout in milliseconds until the specified time.
+ */
+static int libj1939_get_timeout_ms(struct timespec *ts)
+{
+	struct timespec curr_time;
+	int64_t time_diff;
+	int timeout_ms;
+
+	clock_gettime(CLOCK_MONOTONIC, &curr_time);
+	time_diff = timespec_diff_ms(ts, &curr_time);
+	if (time_diff < 0) {
+		/* Too late to send next message. Send it now */
+		timeout_ms = 0;
+	} else {
+		if (time_diff > INT_MAX) {
+			pr_warn("timeout too long: %" PRId64 " ms", time_diff);
+			time_diff = INT_MAX;
+		}
+
+		timeout_ms = time_diff;
+	}
+
+	return timeout_ms;
+}
+
+/**
+ * libj1939_prepare_for_events - Prepare and wait for events on an epoll
+ * @cmn: The common J1939 instance data
+ * @nfds: The number of file descriptors that are ready
+ * @dont_wait: Don't wait for events, just check if there are any
+ *
+ * This function calculates the timeout until the next message should be sent
+ * or any other event should be handled, prepares the epoll instance for events
+ * by waiting for the specified timeout or until an event occurs, and waits for
+ * events on the epoll instance.
+ *
+ * Return: 0 on success, or a negative error code.
+ */
+int libj1939_prepare_for_events(struct libj1939_cmn *cmn, int *nfds,
+				bool dont_wait)
+{
+	int ret, timeout_ms;
+
+	if (dont_wait)
+		timeout_ms = 0;
+	else
+		timeout_ms = libj1939_get_timeout_ms(&cmn->next_send_time);
+
+	ret = epoll_wait(cmn->epoll_fd, cmn->epoll_events,
+			 cmn->epoll_events_size, timeout_ms);
+	if (ret < 0) {
+		ret = -errno;
+		if (ret != -EINTR) {
+			*nfds = 0;
+			return ret;
+		}
+	}
+
+	*nfds = ret;
+
+	ret = clock_gettime(CLOCK_MONOTONIC, &cmn->last_time);
+	if (ret < 0) {
+		ret = -errno;
+		pr_err("failed to get time: %i (%s)", ret, strerror(ret));
+		return ret;
+	}
+
+	return 0;
+}
--- a/libj1939.h
+++ b/libj1939.h
@ -13,9 +13,12 @@
 /* needed on some 64 bit platforms to get consistent 64-bit types */
 #define __SANE_USERSPACE_TYPES__

-#include <sys/socket.h>
 #include <linux/can.h>
 #include <linux/can/j1939.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <time.h>
+#include <sys/socket.h>

 #ifndef J1939_LIB_H
 #define J1939_LIB_H
@ -24,10 +27,30 @@
 extern "C" {
 #endif

+struct libj1939_cmn {
+	int epoll_fd;
+	struct epoll_event *epoll_events;
+	size_t epoll_events_size;
+	struct timespec next_send_time;
+	struct timespec last_time;
+};
+
 void libj1939_parse_canaddr(char *spec, struct sockaddr_can *paddr);
 extern int libj1939_str2addr(const char *str, char **endp, struct sockaddr_can *can);
 extern const char *libj1939_addr2str(const struct sockaddr_can *can);

+void libj1939_init_sockaddr_can(struct sockaddr_can *sac, uint32_t pgn);
+
+int libj1939_open_socket(void);
+int libj1939_bind_socket(int sock, struct sockaddr_can *addr);
+int libj1939_socket_prio(int sock, int prio);
+int libj1939_set_broadcast(int sock);
+int libj1939_add_socket_to_epoll(int epoll_fd, int sock, uint32_t events);
+int libj1939_create_epoll(void);
+
+int libj1939_prepare_for_events(struct libj1939_cmn *cmn, int *nfds,
+				bool dont_wait);
+
 #ifdef __cplusplus
 }
 #endif
--- a/log2asc.c
+++ b/log2asc.c
@ -54,6 +54,15 @@

 #include "lib.h"

+/* relevant flags in Flags field */
+#define ASC_F_RTR 0x00000010
+#define ASC_F_FDF 0x00001000
+#define ASC_F_BRS 0x00002000
+#define ASC_F_ESI 0x00004000
+#define ASC_F_XLF 0x00400000
+#define ASC_F_RES 0x00800000
+#define ASC_F_SEC 0x01000000
+
 extern int optind, opterr, optopt;

 static void print_usage(char *prg)
@ -65,18 +74,17 @@ static void print_usage(char *prg)
 	fprintf(stderr, "         -O <outfile>  (default stdout)\n");
 	fprintf(stderr, "         -4  (reduce decimal place to 4 digits)\n");
 	fprintf(stderr, "         -n  (set newline to cr/lf - default lf)\n");
-	fprintf(stderr, "         -f  (use CANFD format also for Classic CAN)\n");
+	fprintf(stderr, "         -f  (use CANFD format also for CAN CC)\n");
+	fprintf(stderr, "         -x  (use CANXL format also for CAN CC/FD)\n");
 	fprintf(stderr, "         -r  (suppress dlc for RTR frames - pre v8.5 tools)\n");
 }

-static void can_asc(struct canfd_frame *cfd, int devno, int nortrdlc,
+static void can_asc(struct can_frame *cf, int devno, int nortrdlc,
 		    char *extra_info, FILE *outfile)
 {
-	int i;
+	unsigned int i, dlc;
 	char id[10];
 	char *dir = "Rx";
-	int dlc;
-	struct can_frame *cf = (struct can_frame *)cfd; /* for len8_dlc */

 	fprintf(outfile, "%-2d ", devno); /* channel number left aligned */

@ -93,7 +101,7 @@ static void can_asc(struct canfd_frame *cfd, int devno, int nortrdlc,
 				dir = "Tx";
 		}

-		fprintf(outfile, "%-15s %s   ", id, dir);
+		fprintf(outfile, "%-15s %-4s ", id, dir);

 		if (cf->len == CAN_MAX_DLC &&
 		    cf->len8_dlc > CAN_MAX_DLC &&
@ -120,19 +128,13 @@ static void can_asc(struct canfd_frame *cfd, int devno, int nortrdlc,
 static void canfd_asc(struct canfd_frame *cf, int devno, int mtu,
 		      char *extra_info, FILE *outfile)
 {
-	int i;
+	unsigned int i;
 	char id[10];
 	char *dir = "Rx";
 	unsigned int flags = 0;
 	unsigned int dlen = cf->len;
 	unsigned int dlc = can_fd_len2dlc(dlen);

-	/* relevant flags in Flags field */
-#define ASC_F_RTR 0x00000010
-#define ASC_F_FDF 0x00001000
-#define ASC_F_BRS 0x00002000
-#define ASC_F_ESI 0x00004000
-
 	/* check for extra info */
 	if (strlen(extra_info) > 0) {
 		/* only the first char is defined so far */
@ -140,7 +142,7 @@ static void canfd_asc(struct canfd_frame *cf, int devno, int mtu,
 			dir = "Tx";
 	}

-	fprintf(outfile, "CANFD %3d %s ", devno, dir); /* 3 column channel number right aligned */
+	fprintf(outfile, "CANFD %3d %-4s ", devno, dir); /* 3 column channel number right aligned */

 	sprintf(id, "%X%c", cf->can_id & CAN_EFF_MASK,
 		(cf->can_id & CAN_EFF_FLAG)?'x':' ');
@ -174,13 +176,124 @@ static void canfd_asc(struct canfd_frame *cf, int devno, int mtu,

 	fprintf(outfile, "%2d", dlen);

-	for (i = 0; i < (int)dlen; i++) {
+	for (i = 0; i < dlen; i++) {
 		fprintf(outfile, " %02X", cf->data[i]);
 	}

 	fprintf(outfile, " %8d %4d %8X 0 0 0 0 0", 130000, 130, flags);
 }

+static void canxl_asc(cu_t *cu, int devno, int mtu,
+		      char *extra_info, FILE *outfile)
+{
+	char id[10];
+	char *dir = "Rx";
+	char *frametype;
+	unsigned char *dataptr;
+	unsigned int i, dlen, dlc, flags = 0;
+
+	/* check for extra info */
+	if (strlen(extra_info) > 0) {
+		/* only the first char is defined so far */
+		if (extra_info[0] == 'T')
+			dir = "Tx";
+	}
+
+	switch (mtu) {
+	case CANXL_MTU:
+		sprintf(id, "%X", cu->xl.prio & CANXL_PRIO_MASK);
+		frametype = "XLFF";
+
+		dataptr = &cu->xl.data[0];
+		dlen = cu->xl.len;
+		dlc = dlen - 1;
+		flags = (ASC_F_XLF | ASC_F_FDF | ASC_F_BRS);
+
+		if (cu->xl.flags & CANXL_SEC)
+			flags |= ASC_F_SEC;
+		if (cu->xl.flags & CANXL_RRS)
+			flags |= ASC_F_RES;
+		break;
+
+	case CANFD_MTU:
+		if (cu->fd.can_id & CAN_EFF_FLAG) {
+			sprintf(id, "%Xx", cu->fd.can_id & CAN_EFF_MASK);
+			frametype = "FEFF";
+		} else {
+			sprintf(id, "%X", cu->fd.can_id & CAN_SFF_MASK);
+			frametype = "FBFF";
+		}
+
+		dataptr = &cu->fd.data[0];
+		dlen = cu->fd.len;
+		dlc = can_fd_len2dlc(dlen);
+		flags = ASC_F_FDF;
+		if (cu->fd.flags & CANFD_BRS)
+			flags |= ASC_F_BRS;
+		if (cu->fd.flags & CANFD_ESI)
+			flags |= ASC_F_ESI;
+		break;
+
+	case CAN_MTU:
+		if (cu->cc.can_id & CAN_EFF_FLAG) {
+			sprintf(id, "%Xx", cu->cc.can_id & CAN_EFF_MASK);
+			frametype = "CEFF";
+		} else {
+			sprintf(id, "%X", cu->cc.can_id & CAN_SFF_MASK);
+			frametype = "CBFF";
+		}
+
+		dataptr = &cu->cc.data[0];
+		dlen = cu->cc.len;
+		dlc = dlen ;
+
+		/* check for extra DLC when having a Classic CAN with 8 bytes payload */
+		if ((dlen == CAN_MAX_DLEN) && (cu->cc.len8_dlc > CAN_MAX_DLEN) &&
+		    (cu->cc.len8_dlc <= CAN_MAX_RAW_DLC))
+			dlc = cu->cc.len8_dlc;
+
+		if (cu->cc.can_id & CAN_RTR_FLAG) {
+			/* no data length but dlc for RTR frames */
+			dlen = 0;
+			flags = ASC_F_RTR;
+		}
+		break;
+
+	default:
+		return;
+	}
+
+	fprintf(outfile, "CANXL %3d %-4s ", devno, dir); /* 3 column channel number and direction */
+
+	fprintf(outfile, "%s   984438   4656 ", frametype); /* frame type / msg duration / bit count */
+
+	fprintf(outfile, "%9s                                  ", id); /* ID / symbolic name (empty) */
+
+	if (mtu == CANXL_MTU) /* SDT, SEC bit for CAN XL only */
+		fprintf(outfile, "%02x %d ", cu->xl.sdt, (cu->xl.flags & CANXL_SEC)?1:0);
+
+	fprintf(outfile, "%x %d", dlc, dlen); /* DLC and data length */
+
+	if (mtu == CANXL_MTU) /* SBC / PCRC / VCID / AF */
+		fprintf(outfile, " 1 1f96 %02x %08x",
+			(unsigned char)((cu->xl.prio >> CANXL_VCID_OFFSET) & CANXL_VCID_VAL_MASK),
+			cu->xl.af);
+
+	for (i = 0; i < dlen; i++) {
+		fprintf(outfile, " %02x", dataptr[i]);
+	}
+
+	if (mtu == CANFD_MTU) /* stuff field */
+		fprintf(outfile, " 8");
+
+	fprintf(outfile, " 123123 %08x %08x", flags, 0); /* fcsc, msg flags, msg flags ext */
+
+	fprintf(outfile, /* bitrate settings for CC/FD/XL */
+		" 000000050005000e 0000000000a00010"
+		" 0000000a000a001d 0000000000a00002"
+		" 000000100010000f 0000000000a00001");
+}
+
 #define DEVSZ 22
 #define EXTRASZ 20
 #define TIMESZ sizeof("(1345212884.318850)   ")
@ -205,11 +318,11 @@ int main(int argc, char **argv)
 	static struct timeval tv, start_tv;
 	FILE *infile = stdin;
 	FILE *outfile = stdout;
-	static int maxdev, devno, i, crlf, fdfmt, nortrdlc, d4, opt, mtu;
+	static int maxdev, devno, i, crlf, fdfmt, xlfmt, nortrdlc, d4, opt, mtu;
 	int print_banner = 1;
 	unsigned long long sec, usec;

-	while ((opt = getopt(argc, argv, "I:O:4nfr?")) != -1) {
+	while ((opt = getopt(argc, argv, "I:O:4nfxr?")) != -1) {
 		switch (opt) {
 		case 'I':
 			infile = fopen(optarg, "r");
@ -235,6 +348,10 @@ int main(int argc, char **argv)
 			fdfmt = 1;
 			break;

+		case 'x':
+			xlfmt = 1;
+			break;
+
 		case 'r':
 			nortrdlc = 1;
 			break;
@ -300,6 +417,9 @@ int main(int argc, char **argv)
 				(crlf)?"\r\n":"\n");
 			fprintf(outfile, "no internal events logged%s",
 				(crlf)?"\r\n":"\n");
+			fprintf(outfile, "// version 18.2.0%s", (crlf)?"\r\n":"\n");
+			fprintf(outfile, "// Measurement UUID: cc9c7b54-68ae-"
+				"46d2-a43a-6aa87df7dd74%s", (crlf)?"\r\n":"\n");
 		}

 		for (i = 0, devno = 0; i < maxdev; i++) {
@ -313,14 +433,8 @@ int main(int argc, char **argv)

 			mtu = parse_canframe(afrbuf, &cu);

-			/* convert only CAN CC and CAN FD frames */
-			if ((mtu != CAN_MTU) && (mtu != CANFD_MTU)) {
-				printf("no valid CAN CC/FD frame\n");
-				return 1;
-			}
-
-			/* we don't support error message frames in CAN FD */
-			if ((mtu == CANFD_MTU) && (cu.cc.can_id & CAN_ERR_FLAG))
+			/* no error message frames in non CAN CC frames */
+			if ((mtu != CAN_MTU) && (cu.cc.can_id & CAN_ERR_FLAG))
 				continue;

 			tv.tv_sec  = tv.tv_sec - start_tv.tv_sec;
@ -335,10 +449,12 @@ int main(int argc, char **argv)
 			else
 				fprintf(outfile, "%4llu.%06llu ", (unsigned long long)tv.tv_sec, (unsigned long long)tv.tv_usec);

-			if ((mtu == CAN_MTU) && (fdfmt == 0))
-				can_asc(&cu.fd, devno, nortrdlc, extra_info, outfile);
-			else
+			if ((mtu == CAN_MTU) && (fdfmt == 0) && (xlfmt == 0))
+				can_asc(&cu.cc, devno, nortrdlc, extra_info, outfile);
+			else if ((mtu != CANXL_MTU) && (xlfmt == 0))
 				canfd_asc(&cu.fd, devno, mtu, extra_info, outfile);
+			else
+				canxl_asc(&cu, devno, mtu, extra_info, outfile);

 			if (crlf)
 				fprintf(outfile, "\r");
--- a/slcand.c
+++ b/slcand.c
@ -160,7 +160,7 @@ static int look_up_uart_speed(long int s)
 		return B3500000;
 #endif
 #ifdef B3710000
-	case 3710000
+	case 3710000:
 		return B3710000;
 #endif
 #ifdef B4000000
Author	SHA1	Message	Date
Zeljko Avramovic	491cabea07	canerrsim: add Link: https://github.com/linux-can/can-utils/issues/525#issue-2311379340	2025-03-02 17:16:21 +01:00
Marc Kleine-Budde	f1cea504a4	Merge pull request #583 from yegorich/typos isobusfs: fix typos	2025-03-02 17:09:17 +01:00
Marc Kleine-Budde	900c7e9f6e	Merge pull request #584 from yegorich/fix-switch-case slcand.c: add the missing case colon	2025-03-02 17:08:23 +01:00
Yegor Yefremov	b208876e65	slcand.c: add the missing case colon Signed-off-by: Yegor Yefremov <yegorslists@googlemail.com>	2025-03-02 15:51:45 +01:00
Yegor Yefremov	72a9fd8ccd	isobusfs: fix typos Typos were found with codespell. Signed-off-by: Yegor Yefremov <yegorslists@googlemail.com>	2025-03-02 15:44:40 +01:00
Marc Kleine-Budde	a24bff8b08	Merge pull request #582 from yegorich/clangd CMakeLists.txt: enable CMAKE_EXPORT_COMPILE_COMMANDS by default	2025-03-01 16:47:48 +01:00
Yegor Yefremov	fe9ea67814	CMakeLists.txt: enable CMAKE_EXPORT_COMPILE_COMMANDS by default Signed-off-by: Yegor Yefremov <yegorslists@googlemail.com>	2025-03-01 16:15:08 +01:00
Marc Kleine-Budde	6050aa155d	Merge pull request #581 from yegorich/cmake-linting CMakeLists.txt: remove unneeded spaces	2025-03-01 12:33:50 +01:00
Yegor Yefremov	302184f383	CMakeLists.txt: remove unneeded spaces Signed-off-by: Yegor Yefremov <yegorslists@googlemail.com>	2025-03-01 10:51:12 +01:00
Oliver Hartkopp	c542c9ada7	gitignore: remove accidentally added Makefile item Fixes: `4577316bd6` ("Update .gitignore") Link: https://github.com/linux-can/can-utils/pull/577#issuecomment-2690362731 Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>	2025-02-28 21:34:03 +01:00
Khem Raj	2b8c7c5f4b	Include time.h for timespec struct definition Fixes git/isobusfs/../libj1939.h:33:18: error: field has incomplete type 'struct timespec' 33 \| struct timespec next_send_time; \| ^ Signed-off-by: Khem Raj <raj.khem@gmail.com>	2025-02-14 12:41:31 +01:00
Jan Engelhardt	4577316bd6	Update .gitignore	2025-02-14 12:40:42 +01:00
Marc Kleine-Budde	4364d655b8	Merge pull request #576 from jengelh/master build: give libisobusfs a version	2025-02-12 16:55:15 +01:00
Jan Engelhardt	2e71e396c5	build: give libisobusfs a version	2025-02-10 15:32:27 +01:00
Marc Kleine-Budde	01083a64eb	Merge pull request #573 from hartkopp/canxl-asc-conversion CANXL support for ASC conversion tools	2025-01-24 15:39:01 +01:00
Oliver Hartkopp	008f9f8e22	asc2log: add option to disable direction info The ASC file provides an information whether the CAN frame is sent (Tx) or received (Rx) on the local CAN node. With the new '-d' option the generation of this information is disabled for the log file generation to simplify the comparision of log files. E.g. log1 -> asc -> log2 always created the T/R information in the log2 file which is then hard to compare to the log1 file which might not have the T/R information at all. Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>	2025-01-24 15:08:46 +01:00
Oliver Hartkopp	66e7c08beb	log2asc: add CAN XL support Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>	2025-01-24 15:04:43 +01:00
Oliver Hartkopp	4b66e8c56f	asc2log: shrink string buffer for header analysis Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>	2025-01-24 14:59:57 +01:00
Oliver Hartkopp	e6e3253972	asc2log: shrink string buffer for CAN identifier Since using the %n feature the tmp1 buffer is only used for the handling of the CAN identifier. So this buffer can be shrinked for that use case. Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>	2025-01-24 14:56:16 +01:00
Oliver Hartkopp	6d69bef837	asc2log: add CAN CC and CAN FD support for CAN XL message events Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>	2025-01-24 14:51:52 +01:00
Oliver Hartkopp	4d8b247258	asc2log: make use of sscanf consumed characters feature Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>	2025-01-24 14:48:32 +01:00
Oliver Hartkopp	0e9c53f6d3	asc2log: add CAN XL support for CAN XL message events Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>	2025-01-24 14:33:59 +01:00
Oliver Hartkopp	99c5c14790	can.h: canxl: support Remote Request Substitution bit access The Remote Request Substitution bit is a dominant bit ("0") in the CAN XL frame. As some CAN XL controllers support to access this bit a new CANXL_RRS value has been defined for the canxl_frame.flags element. Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>	2025-01-24 14:22:21 +01:00
Oliver Hartkopp	df8e08fa70	asc2log: prepare helper functions for CAN XL frame handling Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>	2025-01-24 14:22:21 +01:00
Oliver Hartkopp	cb5ab07f34	asc2log: handle and skip TxRq messages TxRq messages are internal measurement messages that document the time of a transmission request (to the CAN driver) to be checked against the real transmission time, when the CAN message has been sent. There is no such feature in the SocketCAN log format, so we detect this tag but skip TxRq messages in the ASC log files. Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>	2025-01-24 14:22:21 +01:00
Oliver Hartkopp	0e692bf42e	asc2log: unify multi-line comments Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>	2025-01-24 14:21:59 +01:00
Marc Kleine-Budde	0984817438	Merge pull request #571 from marckleinebudde/cangen-canbusload cangen, canbusload: new features	2025-01-22 15:54:06 +01:00
Zhu Yi	b3da2f62b9	canbusload: support busload visualization Add '-v' option for visualize busload, the output shows a moving histogram of the past 90 seconds. canbusload 2024-09-23 17:19:33 (exact bitstuffing) can0@500k 487 55558 31048 0 99% \|XXXXXXXXXXXXXXXXXXX.\| 100%\|.......................................................................................... 95%\|..............................................................................XXXXXXXXXXXX 90%\|.............................................................................XXXXXXXXXXXXX 85%\|.............................................................................XXXXXXXXXXXXX 80%\|.............................................................................XXXXXXXXXXXXX 75%\|.............................................................................XXXXXXXXXXXXX 70%\|.............................................................................XXXXXXXXXXXXX 65%\|.............................................................................XXXXXXXXXXXXX 60%\|............................................................................XXXXXXXXXXXXXX 55%\|............................................................................XXXXXXXXXXXXXX 50%\|............................................................................XXXXXXXXXXXXXX 45%\|............................................................................XXXXXXXXXXXXXX 40%\|............................................................................XXXXXXXXXXXXXX 35%\|.........................................XXX................................XXXXXXXXXXXXXX 30%\|.........................................XXXX...............................XXXXXXXXXXXXXX 25%\|........................................XXXXXX.............................XXXXXXXXXXXXXXX 20%\|XXXXXXXX...............................XXXXXXXXXXXXXXXXX....XXXXXXXXXXX...XXXXXXXXXXXXXXXX 15%\|XXXXXXXXX.............................XXXXXXXXXXXXXXXXXXXX.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 10%\|XXXXXXXXX.XXXXXXXXXXXXXXXXXXX..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 5%\|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX Signed-off-by: Zhu Yi <yi.zhu5@cn.bosch.com> Signed-off-by: Hubert Streidl <hubert.streidl@de.bosch.com> Signed-off-by: Mark Jonas <mark.jonas@de.bosch.com> Link: https://lore.kernel.org/r/20250120162332.19157-3-mark.jonas@de.bosch.com Signed-off-by: Marc Kleine-Budde <mkl@pengutronix.de>	2025-01-20 18:07:16 +01:00
Zhu Yi	b85418d75c	canbusload: support busload statistic Add '-s' option for display busload statistic, the output contains minimal, maximum and exponentially-damped moving sums of one second average (borrowed from Linux load average algorithm) since start or reset (press 'r' while running). canbusload 2024-09-23 17:15:18 (exact bitstuffing) can0@500k 942 107535 60168 0 18% min: 0%, max: 21%, load: 16% 6% 2% \|XXX.................\| Signed-off-by: Zhu Yi <yi.zhu5@cn.bosch.com> Signed-off-by: Hubert Streidl <hubert.streidl@de.bosch.com> Signed-off-by: Mark Jonas <mark.jonas@de.bosch.com> Link: https://lore.kernel.org/r/20250120162332.19157-2-mark.jonas@de.bosch.com Signed-off-by: Marc Kleine-Budde <mkl@pengutronix.de>	2025-01-20 18:01:10 +01:00
Zhu Yi	6eb97b57c5	cangen: support socket priority Add '-P' option for allow user to set the socket priority. This can be useful in conjuction with queuing discipline. Signed-off-by: Zhu Yi <yi.zhu5@cn.bosch.com> Signed-off-by: Hubert Streidl <hubert.streidl@de.bosch.com> Signed-off-by: Mark Jonas <mark.jonas@de.bosch.com> Link: https://lore.kernel.org/r/20250120162332.19157-1-mark.jonas@de.bosch.com Signed-off-by: Marc Kleine-Budde <mkl@pengutronix.de>	2025-01-20 18:01:10 +01:00
Marc Kleine-Budde	fc1f6979c0	Merge pull request #568 from marckleinebudde/j1939 can-j1939-install-kernel-module: convert to Unix line endings and remove trailing whitespace	2024-12-11 15:02:35 +01:00
Marc Kleine-Budde	24e0c520b6	can-j1939-install-kernel-module: convert to Unix line endings and remove trailing whitespace	2024-12-11 15:01:58 +01:00
Marc Kleine-Budde	06561ac3dc	Merge pull request #566 from marckleinebudde/canfdtest canfdtest: compare_frame: add 0x prefix to indicate hex value	2024-12-11 11:03:12 +01:00
Marc Kleine-Budde	7093a73185	canfdtest: compare_frame: add 0x prefix to indicate hex value	2024-12-11 10:24:33 +01:00
Marc Kleine-Budde	72f236e3ac	Merge pull request #565 from yegorich/fix-code-analysis-workflow CI: fix codeql-analysis	2024-12-09 11:17:38 +01:00
Yegor Yefremov	3bbc8075eb	CI: fix codeql-analysis v1 is deprecated. Thus, use the latest version v3 instead. Signed-off-by: Yegor Yefremov <yegorslists@googlemail.com>	2024-12-09 11:05:40 +01:00
Oliver Hartkopp	6526683a10	Merge pull request #556 from hartkopp/master Fix and rework canbusload	2024-08-09 15:02:26 +02:00
Oliver Hartkopp	dced0a6ec7	canbusload: fix and improve the bitrate output With the introduction of CAN FD the bitrate has not been printed correcty. Fix the CAN FD bitrate output and try to shrink the bitrates by using kilo or Mega suffixes: 500000 -> 500k Fixes: `6382765bf6` ("canbusload: count databitrate seperately") Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>	2024-08-08 17:36:49 +02:00
Marc Kleine-Budde	6c36d44c83	Merge pull request #555 from marckleinebudde/readme-update-link README: update link to kernel documentation	2024-08-08 14:14:10 +02:00
Marc Kleine-Budde	7260844b73	README: update link to kernel documentation The can.txt is obsolete, move to rendered html instead.	2024-08-08 14:06:59 +02:00
Oliver Hartkopp	be1fc77311	gitignore: add j1939-timedate-cli and j1939-timedate-srv Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>	2024-08-08 11:03:15 +02:00
Oliver Hartkopp	fc2473424e	canbusload: show RX/TX direction in bargraph Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>	2024-08-08 10:04:55 +02:00
Oliver Hartkopp	724e6f7c11	canbusload: use recvmsg() instead of recvfrom() To access msg_flags for RX/TX direction detection. Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>	2024-08-07 21:29:49 +02:00
Oliver Hartkopp	7665e1e236	canbusload: add auto detection of CAN interfaces Rework to use a single CAN socket for the received CAN traffic. This allows to shutdown and restart various CAN interfaces without terminating the application. Additionally an auto detection has been implemented with the 'any' CAN interface. E.g. with any@500000,2000000 CAN interfaces that have not been defined before are assigned with the given 'any' bitrates when a CAN frame from this CAN interface has been received. Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>	2024-08-07 19:57:08 +02:00
Oliver Hartkopp	b592ec5b1f	canbusload: fix string length check for CAN FD The CAN interface description can now have two bitrates. Extend the length check to handle the CAN FD data bitrate correctly. Fixes: `6382765bf6` ("canbusload: count databitrate seperately") Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>	2024-08-07 13:02:05 +02:00
Oliver Hartkopp	30b6b04053	isotpdump: add color support for functional addressing traffic Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>	2024-08-06 16:26:14 +02:00
chris	367e0df4aa	isotpdump: option to capture functional addressing traffic add option '-b' to capture functional broadcast data eg: -b 98DAFFF1 or -b 18DAFFF1	2024-08-06 16:12:18 +02:00
Oleksij Rempel	8a156fee19	Merge pull request #552 from pseiderer/ps-devel-fix-uclibc-compile-002 j1939acd: remove legacy '-p' option (prefix to use when logging)	2024-07-24 09:36:00 +02:00
Peter Seiderer	a63bf468c2	j1939sr: remove legacy program_invocation_name/program_invocation_short_name code - remove legacy program_invocation_name/program_invocation_short_name code Signed-off-by: Peter Seiderer <ps.report@gmx.net>	2024-07-22 16:18:21 +02:00
Peter Seiderer	d337863d91	j1939acd: remove legacy '-p' option (prefix to use when logging) - remove legacy '-p' option (prefix to use when logging), fixes uclibc compile Fixes: j1939acd.c: In function 'main': j1939acd.c:489:38: error: passing argument 1 of 'asprintf' from incompatible pointer type [-Wincompatible-pointer-types] 489 \| if (asprintf(&program_invocation_name, "%s.%s", \| ^~~~~~~~~~~~~~~~~~~~~~~~ \| \| \| const char ** Signed-off-by: Peter Seiderer <ps.report@gmx.net>	2024-07-22 16:14:48 +02:00
Marc Kleine-Budde	95fe6522c6	Merge pull request #548 from marckleinebudde/workflow-debian-experimental github-actions: add debian:experimental	2024-06-20 09:05:12 +02:00
Marc Kleine-Budde	fe514eedf8	github-actions: add debian:experimental	2024-06-20 08:41:48 +02:00
Marc Kleine-Budde	4eb72fd39a	Merge pull request #547 from vuquangtrong/master asc2log::get_date check for AM in en_US time format	2024-06-12 08:58:32 +02:00
vuquangtrong	51b1f67851	asc2log::get_date check for AM in en_US time format	2024-06-12 13:48:53 +07:00
Marc Kleine-Budde	847486083a	Merge pull request #546 from marckleinebudde/activate-Wsign-compare cmake: add -Wsign-compare	2024-06-07 13:22:32 +02:00
Marc Kleine-Budde	f6db81da68	cmake: add -Wsign-compare	2024-06-07 09:58:13 +02:00
Oliver Hartkopp	15dbb474c7	j1939_timedate_cli: fix sign-compare warning Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>	2024-06-07 09:09:26 +02:00
Oliver Hartkopp	4b86049167	Makefile: add j1939 datetime tools Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>	2024-06-07 09:09:26 +02:00
Marc Kleine-Budde	cf0091c90c	Merge pull request #524 from olerem/j1939-datetime-2024.05.15 Add support for the J1939 TimeDate services	2024-06-06 21:29:13 +02:00
Oleksij Rempel	d0b04bd456	add j1939 datetime Implement client and server side for SAE J1939-71:2002 - 5.3 pgn65254 - Time/Date - TD. Testing: ./j1939-timedate-srv -i vcan0 -a 0x70 & ./j1939-timedate-cli -i vcan0 -a 0x80 -r 0xff Signed-off-by: Oleksij Rempel <linux@rempel-privat.de>	2024-06-06 13:54:26 +02:00
Oleksij Rempel	af95ee0c6d	move part of isobusfs code to the libj1939 Move part of isobusfs which can be reused by other applications to the libj1939. By the way, reuse some of new libj1939 code in the j1939cat. Signed-off-by: Oleksij Rempel <linux@rempel-privat.de>	2024-06-06 13:53:19 +02:00
Oleksij Rempel	69c1e8289d	add pr_err and pr_warn macros This variant will be used in the j19393-timeday code. Signed-off-by: Oleksij Rempel <linux@rempel-privat.de>	2024-05-30 09:40:23 +02:00