canerrsim: main(): add missing () to function calls

canerrsim: main(): initialize bool variables
canerrsim: show_help_and_exit(): use "%s" to print string
2024-05-29 21:16:13 +02:00 · 2024-05-29 21:16:13 +02:00 · 2024-05-29 21:16:13 +02:00 · 2024-05-29 21:16:13 +02:00 · 2024-05-29 21:16:13 +02:00 · 2024-05-29 21:16:10 +02:00
37 changed files with 709 additions and 2637 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@v3
+      uses: github/codeql-action/init@v1
      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@v3
+      uses: github/codeql-action/autobuild@v1

    # ℹ️ 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@v3
+      uses: github/codeql-action/analyze@v1
--- a/.github/workflows/compile.yml
+++ b/.github/workflows/compile.yml
@ -17,21 +17,18 @@ 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 ${release} \
+        podman exec -e DEBIAN_FRONTEND='noninteractive' -i -u root stable apt install -o APT::Install-Suggests=false -qy \
                clang \
                cmake \
                gcc \
--- a/.gitignore
+++ b/.gitignore
@ -1,12 +1,6 @@
 *~
-*.a
-*.so
-*.so.*
 *.o
 .ccls-cache
-CMakeCache.txt
-CMakeFiles/
-cmake_install.cmake
 compile_commands.json
 tags
 /build
@ -37,8 +31,6 @@ tags
 /j1939cat
 /j1939spy
 /j1939sr
-/j1939-timedate-cli
-/j1939-timedate-srv
 /log2asc
 /log2long
 /mcp251xfd-dump
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -4,18 +4,14 @@ project(can-utils LANGUAGES C)

 message(STATUS "CMake version: ${CMAKE_VERSION}")

-include(CheckFunctionExists)
-include(CheckSymbolExists)
-include(GNUInstallDirs)
+include (CheckFunctionExists)
+include (CheckSymbolExists)
+include (GNUInstallDirs)

 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)

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

 add_definitions(-D_GNU_SOURCE)

-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wno-parentheses -Wsign-compare")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wno-parentheses")
 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")
@ -36,8 +32,8 @@ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DCLOCK_TAI=11")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DSO_TXTIME=61")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DSCM_TXTIME=SO_TXTIME")

-include_directories(.)
-include_directories(./include)
+include_directories (.)
+include_directories (./include)

 check_function_exists(fork HAVE_FORK)

@ -66,11 +62,6 @@ set(PROGRAMS_J1939
  testj1939
 )

-set(PROGRAMS_J1939_TIMEDATE
-  j1939-timedate-srv
-  j1939-timedate-cli
-)
-
 set(PROGRAMS_ISOBUSFS
  isobusfs-srv
  isobusfs-cli
@ -115,10 +106,6 @@ if(NOT ANDROID)
    libj1939.c
  )

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

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

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

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

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

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

  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
@ -208,7 +168,7 @@ foreach(name ${PROGRAMS})

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

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

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

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

 install:
 	mkdir -p $(DESTDIR)$(PREFIX)/bin
@ -145,15 +139,13 @@ cansend.o:	lib.h
 log2asc.o:	lib.h
 log2long.o:	lib.h
 slcanpty.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
+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
 canframelen.o:  canframelen.h

 asc2log:	asc2log.o	lib.o
@ -167,24 +159,13 @@ cansequence:	cansequence.o	lib.o
 log2asc:	log2asc.o	lib.o
 log2long:	log2long.o	lib.o
 slcanpty:	slcanpty.o	lib.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 $@
+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

 isobusfs-srv:	lib.o \
-		libj1939.o \
 		isobusfs/isobusfs_cmn.o \
 		isobusfs/isobusfs_srv.o \
 		isobusfs/isobusfs_srv_cm.o \
@ -197,7 +178,6 @@ 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/html/latest/networking/can.html)
+*   [SocketCAN Documentation (Linux Kernel)](https://www.kernel.org/doc/Documentation/networking/can.txt)
 *   [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,17 +58,7 @@

 #include "lib.h"

-#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
+#define BUFLEN 400 /* CAN FD mode lines can be pretty long */

 extern int optind, opterr, optopt;

@ -79,12 +69,10 @@ 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,
-		    cu_t *cf, char dir)
+		    struct canfd_frame *cf, char *extra_info)
 {
 	static char abuf[BUFLEN];

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

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

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

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

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

-		if (!strncmp(idstr, "ErrorFrame", strlen("ErrorFrame"))) {
+		if (!strncmp(tmp1, "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, (cu_t *)&cf, NO_DIR);
+			prframe(outfile, &tv, interface, &cf, "\n");
 			fflush(outfile);
 			return;
 		}
@ -187,15 +172,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 %20s %4s %c %x %x %x %x %x %x %x %x %x",
+		items = sscanf(buf, "%llu.%llu %d %s %2s %c %x %x %x %x %x %x %x %x %x",
 			       &sec, &usec, &interface,
-			       idstr, dir, &rtr, &dlc,
+			       tmp1, 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 %20s %4s %c %x %d %d %d %d %d %d %d %d",
+		items = sscanf(buf, "%llu.%llu %d %s %2s %c %x %d %d %d %d %d %d %d %d",
 			       &sec, &usec, &interface,
-			       idstr, dir, &rtr, &dlc,
+			       tmp1, dir, &rtr, &dlc,
 			       &data[0], &data[1], &data[2], &data[3],
 			       &data[4], &data[5], &data[6], &data[7]);

@ -220,9 +205,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.can_id, idstr, 16);
+			get_can_id(&cf, tmp1, 16);
 		else
-			get_can_id(&cf.can_id, idstr, 10);
+			get_can_id(&cf, tmp1, 10);

 		/* dlc > 8 => len == CAN_MAX_DLEN => fill len8_dlc value */
 		if (dlc > CAN_MAX_DLC)
@ -231,9 +216,6 @@ 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;
@ -241,6 +223,11 @@ 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;
@ -249,13 +236,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, (cu_t *)&cf, dir[0]);
+		prframe(outfile, &tv, interface, &cf, extra_info);
 		fflush(outfile);
 	}
 }

 static void eval_canfd(char* buf, struct timeval *date_tvp, char timestamps,
-		       int dplace, int disable_dir, FILE *outfile)
+		       int dplace, FILE *outfile)
 {
 	int interface;
 	static struct timeval tv; /* current frame timestamp */
@ -264,33 +251,29 @@ 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 idstr[21];
-	char dir[5]; /* 'Rx'/'Tx'/'TxRq' plus terminating zero */
+	char tmp1[BUFLEN];
+	char dir[3]; /* 'Rx' or 'Tx' plus terminating zero */
+	char *extra_info;
 	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 %4s %20s %hhx %hhx %x %d %n",
+	if (sscanf(buf, "%llu.%llu %*s %d %2s %s %hhx %hhx %x %d ",
 		   &sec, &usec, &interface,
-		   dir, idstr, &brs, &esi, &dlc, &dlen, &n) != 9) {
+		   dir, tmp1, &brs, &esi, &dlc, &dlen) != 9) {

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

 			/* no valid CANFD format pattern */
 			return;
@ -307,9 +290,6 @@ 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;
@ -318,13 +298,26 @@ 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.can_id, idstr, 16);
+	get_can_id(&cf, tmp1, 16);

-	ptr = buf + n; /* start of ASCII hex frame data */
+	/* 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 */

 	cf.len = dlen;

@ -348,6 +341,12 @@ 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)
@ -374,414 +373,18 @@ 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, (cu_t *)&cf, dir[0]);
+	prframe(outfile, &tv, interface, &cf, extra_info);
 	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, " am ") != NULL) || (strcasestr(date, " pm ") != NULL)) {
+	if (strcasestr(date, " pm ") != NULL) {
 		/* assume EN/US date due to existing am/pm field */

 		if (!setlocale(LC_TIME, "en_US")) {
@ -790,11 +393,9 @@ 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);
@ -809,11 +410,9 @@ 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);
@ -835,11 +434,11 @@ static int get_date(struct timeval *tv, char *date)

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

 	FILE *infile = stdin;
 	FILE *outfile = stdout;
-	static int verbose, disable_dir;
+	static int verbose;
 	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 */
@ -847,7 +446,7 @@ int main(int argc, char **argv)
 	int opt;
 	unsigned long long sec, usec;

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

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

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

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

@ -942,19 +537,15 @@ 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/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);
+		/* 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);
 			else
-				eval_can(buf, &date_tv, timestamps, base, dplace, disable_dir, outfile);
+				eval_can(buf, &date_tv, timestamps, base, dplace, outfile);
 		}
 	}
 	fclose(outfile);
--- a/can-j1939-install-kernel-module.md
+++ b/can-j1939-install-kernel-module.md
@ -1,180 +1,180 @@
-# can-j1939 kernel module installation #
-
-
-
-### Problem
-
-You already have **can0** or **vcan0** up and working, **can-utils** downloaded and compiled to **~/can/can-utils** and you can send and receive frames without problems. However, when you want to bring up **can-j1939** you get error like this:
-
-```bash
-avra@vm-debian:~/can/can-utils$ sudo modprobe can-j1939
-modprobe: FATAL: Module can-j1939 not found in directory /lib/modules/5.7.0.0.bpo.2-amd64
-```
-
-and also this:
-
-```bash
-avra@vm-debian:~/can/can-utils$ testj1939
-testj1939: socket(j1939): Protocol not supported
-```
-
-
-
-### Solution
-
-Above errors mean that **can-j1939** was not enabled in your kernel and you need to compile it manually. There are several ways to do it. Any Linux kernel since 5.4 has **can-j1939** module, but you will probably want to install fresher version, which leads to downloading kernel sources, enabling **can-j1939** module, recompiling kernel and installing it. I will be using Debian 10.5 x64 (buster testing) virtual machine.
-
-
-
-#### 1. Download kernel source ####
-
-We will download Debian patched kernel 5.8. First update your sources
-
-```
-avra@vm-debian:~$ sudo apt update
-```
-
-and then look at available Debian patched kernel source packages
-
-```
-avra@vm-debian:~$ apt-cache search linux-source
-linux-source-4.19 - Linux kernel source for version 4.19 with Debian patches
-linux-source - Linux kernel source (meta-package)
-linux-source-5.4 - Linux kernel source for version 5.4 with Debian patches
-linux-source-5.5 - Linux kernel source for version 5.5 with Debian patches
-linux-source-5.6 - Linux kernel source for version 5.6 with Debian patches
-linux-source-5.7 - Linux kernel source for version 5.7 with Debian patches
-linux-source-5.8 - Linux kernel source for version 5.8 with Debian patches
-```
-
-If kernel 5.8 does not show in your linux-sources list (it shows above in mine since I have already upgraded stock 4.19 kernel to backported 5.7), then you will need to add backports to your sources list. It is best to do it like this
-
-```
-echo 'deb http://deb.debian.org/debian buster-backports main contrib' | sudo tee -a /etc/apt/sources.list.d/debian-backports.list
-```
-
-Alternatively, or in case you have problems with installation of some packages, or you just want to have everything in a single list, here is what my **/etc/apt/sources.list** looks like (you will need to append at least last line to yours)
-
-```
-deb http://security.debian.org/debian-security buster/updates main contrib
-deb-src http://security.debian.org/debian-security buster/updates main contrib
-
-deb http://deb.debian.org/debian/ buster main contrib non-free
-deb-src http://deb.debian.org/debian/ buster main contrib non-free
-
-deb http://deb.debian.org/debian buster-backports main contrib
-```
-
-After adding backports in one way or another, try **sudo apt update** again, and after that **apt-cache search linux-source** should show kernel 5.8 in the list, so you can install it's source package
-
-```
-sudo apt install linux-source-5.8
-```
-
-and unpack it
-```
-avra@vm-debian:~$ cd /usr/src
-avra@vm-debian:/usr/src$ sudo tar -xaf linux-source-5.8.tar.xz
-avra@vm-debian:/usr/src$ cd linux-source-5.8
-```
-
-
-
-#### 2. Add can-j1939 module to kernel ####
-
-First we need some packages for **menuconfig**
-
-```
-sudo apt-get install libncurses5 libncurses5-dev
-```
-
-copy and use our old configuration to run **menuconfig**
-
-```
-avra@vm-debian:/usr/src/linux-source-5.8$ sudo cp /boot/config-$(uname -r) .config
-avra@vm-debian:/usr/src/linux-source-5.8$ sudo make menuconfig
-```
-
-where we enable SAE  J1939 kernel module as shown
-
-```
-	- Networking Support
-		- Can bus subsystem support
-			- <M> SAE J1939
-```
-
-Now edit **/usr/src/linux-source-5.8/.config**, find CONFIG_SYSTEM_TRUSTED_KEYS, change it as following
-```
-CONFIG_SYSTEM_TRUSTED_KEYS=""
-```
-
-and save the file.
-
-
-
-#### 3. Compile and install kernel and modules
-
-We will have to download necessary packages
-
-```
-sudo apt install build-essential libssl-dev libelf-dev bison flex
-```
-
-compile kernel (using threads to make it faster)
-
-```
-avra@vm-debian:/usr/src/linux-source-5.8$ sudo make -j $(nproc)
-```
-
-install
-
-```
-avra@vm-debian:/usr/src/linux-source-5.8$ sudo make modules_install
-avra@vm-debian:/usr/src/linux-source-5.8$ sudo make install
-```
-
-and update grub
-
-```
-avra@vm-debian:/usr/src/linux-source-5.8$ sudo update-grub
-avra@vm-debian:/usr/src/linux-source-5.8$ sudo reboot
-```
-
-Check if installation is correct with
-
-```
-sudo modprobe can-j1939
-```
-
-and if you get no error then you can enjoy **can-j1939**. If you get some error then you might check if this alternative command works:
-
-```
-sudo insmod /lib/modules/5.8.10/kernel/net/can/j1939/can-j1939.ko
-```
-
-If it does then all you need to do is
-
-```
-sudo depmod -av
-```
-
-reboot once, and **modprobe** command from the above should finally work.
-
-
-
-#### 4. Install headers if needed
-
-You might have a problem with headers not being updated. To check that open file **/usr/include/linux/can.h** with
-
-```
-nano /usr/include/linux/can.h
-```
-
-If in the struct **sockaddr_can** you don’t see **j1939**, then header files did not upgrade and you need to do it manually
-
-```
-sudo cp /usr/src/linux-source-5.8/include/uapi/linux/can.h /usr/include/linux/can.h
-sudo cp /usr/src/linux-source-5.8/include/uapi/linux/can/j1939.h /usr/include/linux/can/
-```
-
-That is the minimum for compiling some **J1939** C code, but you might want to upgrade other header files as well. That's up to you. Enjoy!
+# can-j1939 kernel module installation #
+
+
+
+### Problem
+
+You already have **can0** or **vcan0** up and working, **can-utils** downloaded and compiled to **~/can/can-utils** and you can send and receive frames without problems. However, when you want to bring up **can-j1939** you get error like this:
+
+```bash
+avra@vm-debian:~/can/can-utils$ sudo modprobe can-j1939
+modprobe: FATAL: Module can-j1939 not found in directory /lib/modules/5.7.0.0.bpo.2-amd64
+```
+
+and also this:
+
+```bash
+avra@vm-debian:~/can/can-utils$ testj1939
+testj1939: socket(j1939): Protocol not supported
+```
+
+
+
+### Solution
+
+Above errors mean that **can-j1939** was not enabled in your kernel and you need to compile it manually. There are several ways to do it. Any Linux kernel since 5.4 has **can-j1939** module, but you will probably want to install fresher version, which leads to downloading kernel sources, enabling **can-j1939** module, recompiling kernel and installing it. I will be using Debian 10.5 x64 (buster testing) virtual machine.
+
+
+
+#### 1. Download kernel source ####
+
+We will download Debian patched kernel 5.8. First update your sources
+
+```
+avra@vm-debian:~$ sudo apt update
+```
+
+and then look at available Debian patched kernel source packages
+
+```
+avra@vm-debian:~$ apt-cache search linux-source
+linux-source-4.19 - Linux kernel source for version 4.19 with Debian patches
+linux-source - Linux kernel source (meta-package)
+linux-source-5.4 - Linux kernel source for version 5.4 with Debian patches
+linux-source-5.5 - Linux kernel source for version 5.5 with Debian patches
+linux-source-5.6 - Linux kernel source for version 5.6 with Debian patches
+linux-source-5.7 - Linux kernel source for version 5.7 with Debian patches
+linux-source-5.8 - Linux kernel source for version 5.8 with Debian patches
+```
+
+If kernel 5.8 does not show in your linux-sources list (it shows above in mine since I have already upgraded stock 4.19 kernel to backported 5.7), then you will need to add backports to your sources list. It is best to do it like this
+
+```
+echo 'deb http://deb.debian.org/debian buster-backports main contrib' | sudo tee -a /etc/apt/sources.list.d/debian-backports.list
+```
+
+Alternatively, or in case you have problems with installation of some packages, or you just want to have everything in a single list, here is what my **/etc/apt/sources.list** looks like (you will need to append at least last line to yours)
+
+```
+deb http://security.debian.org/debian-security buster/updates main contrib
+deb-src http://security.debian.org/debian-security buster/updates main contrib
+
+deb http://deb.debian.org/debian/ buster main contrib non-free
+deb-src http://deb.debian.org/debian/ buster main contrib non-free
+
+deb http://deb.debian.org/debian buster-backports main contrib
+```
+
+After adding backports in one way or another, try **sudo apt update** again, and after that **apt-cache search linux-source** should show kernel 5.8 in the list, so you can install it's source package
+
+```
+sudo apt install linux-source-5.8
+```
+
+and unpack it
+```
+avra@vm-debian:~$ cd /usr/src
+avra@vm-debian:/usr/src$ sudo tar -xaf linux-source-5.8.tar.xz
+avra@vm-debian:/usr/src$ cd linux-source-5.8
+```
+
+
+
+#### 2. Add can-j1939 module to kernel ####
+
+First we need some packages for **menuconfig** 
+
+```
+sudo apt-get install libncurses5 libncurses5-dev
+```
+
+copy and use our old configuration to run **menuconfig**
+
+```
+avra@vm-debian:/usr/src/linux-source-5.8$ sudo cp /boot/config-$(uname -r) .config
+avra@vm-debian:/usr/src/linux-source-5.8$ sudo make menuconfig
+```
+
+where we enable SAE  J1939 kernel module as shown
+
+```
+	- Networking Support
+		- Can bus subsystem support
+			- <M> SAE J1939
+```
+
+Now edit **/usr/src/linux-source-5.8/.config**, find CONFIG_SYSTEM_TRUSTED_KEYS, change it as following
+```
+CONFIG_SYSTEM_TRUSTED_KEYS=""
+```
+
+and save the file.
+
+
+
+#### 3. Compile and install kernel and modules
+
+We will have to download necessary packages
+
+```
+sudo apt install build-essential libssl-dev libelf-dev bison flex
+```
+
+compile kernel (using threads to make it faster)
+
+```
+avra@vm-debian:/usr/src/linux-source-5.8$ sudo make -j $(nproc)
+```
+
+install
+
+```
+avra@vm-debian:/usr/src/linux-source-5.8$ sudo make modules_install
+avra@vm-debian:/usr/src/linux-source-5.8$ sudo make install
+```
+
+and update grub
+
+```
+avra@vm-debian:/usr/src/linux-source-5.8$ sudo update-grub
+avra@vm-debian:/usr/src/linux-source-5.8$ sudo reboot
+```
+
+Check if installation is correct with
+
+```
+sudo modprobe can-j1939
+```
+
+and if you get no error then you can enjoy **can-j1939**. If you get some error then you might check if this alternative command works:
+
+```
+sudo insmod /lib/modules/5.8.10/kernel/net/can/j1939/can-j1939.ko
+```
+
+If it does then all you need to do is 
+
+```
+sudo depmod -av
+```
+
+reboot once, and **modprobe** command from the above should finally work.
+
+
+
+#### 4. Install headers if needed
+
+You might have a problem with headers not being updated. To check that open file **/usr/include/linux/can.h** with
+
+```
+nano /usr/include/linux/can.h
+```
+
+If in the struct **sockaddr_can** you don’t see **j1939**, then header files did not upgrade and you need to do it manually
+
+```
+sudo cp /usr/src/linux-source-5.8/include/uapi/linux/can.h /usr/include/linux/can.h
+sudo cp /usr/src/linux-source-5.8/include/uapi/linux/can/j1939.h /usr/include/linux/can/
+```
+
+That is the minimum for compiling some **J1939** C code, but you might want to upgrade other header files as well. That's up to you. Enjoy!
--- a/canbusload.c
+++ b/canbusload.c
@ -45,17 +45,14 @@
 #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>
@ -68,69 +65,34 @@
 #include "terminal.h"
 #include "canframelen.h"

-#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 MAXSOCK 16    /* 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;
-	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];
+} stat[MAXSOCK + 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_bitratestr_len;
-static unsigned int currmax;
+static int max_bitrate_len;
+static 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)
 {
@ -144,23 +106,21 @@ 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", 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, "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, "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) (bits total) (bits payload) (bits payload brs)\n");
+	fprintf(stderr, "(interface) (received CAN frames) (used bits total) (used bits for payload)\n");
 	fprintf(stderr, "\nExamples:\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, "\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, "\n");
 }

@ -170,45 +130,9 @@ 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)
 {
-	unsigned int i, j, k, percent, index;
+	int i, j, percent;

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

-		printf(" %*s@%-*s %5d %7d %7d %7d %3d%%",
+		printf(" %*s@%-*d %5d %7d %6d %6d %3d%%",
 		       max_devname_len, stat[i].devname,
-		       max_bitratestr_len, stat[i].bitratestr,
+		       max_bitrate_len, stat[i].bitrate,
 		       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(" |");
@ -312,7 +212,7 @@ static void printstats(int signo)

 			for (j = 0; j < NUMBAR; j++) {
 				if (j < percent / PERCENTRES)
-					printf("%c", stat[i].recv_direction);
+					printf("X");
 				else
 					printf(".");
 			}
@ -320,28 +220,6 @@ 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);

@ -352,11 +230,8 @@ 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");

@ -365,35 +240,17 @@ 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;
+	int s[MAXSOCK];
+
 	int opt;
 	char *ptr, *nptr;
 	struct sockaddr_can addr;
 	struct canfd_frame frame;
-	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);
+	int nbytes, i;
+	struct ifreq ifr;

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

 	prg = basename(argv[0]);

-	while ((opt = getopt(argc, argv, "rtbciesvh?")) != -1) {
+	while ((opt = getopt(argc, argv, "rtbcieh?")) != -1) {
 		switch (opt) {
 		case 'r':
 			redraw = 1;
@ -429,15 +286,6 @@ 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);
@ -452,22 +300,27 @@ int main(int argc, char **argv)

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

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

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

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

-		pr_debug("handle %d '%s'.\n", i, ptr);
+		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;
+		}

 		nptr = strchr(ptr, '@');

@ -477,76 +330,55 @@ 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;
-		 /* bitrate is placed behind the '@' */
-		stat[i].bitrate = strtol(nptr + 1, &endp, 0);
-
-		/* check for CAN FD additional data bitrate */
+		stat[i].bitrate = strtol(nptr + 1, &endp, 0); /* bitrate is placed behind the '@' */
 		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 ||
-		    !stat[i].dbitrate || stat[i].dbitrate > 8000000) {
+		if (!stat[i].bitrate || stat[i].bitrate > 1000000) {
 			printf("invalid bitrate for CAN device '%s'!\n", ptr);
 			return 1;
 		}

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

-		stat[i].recv_direction = '.';
+		pr_debug("using interface name '%s'.\n", ifr.ifr_name);

-		/* 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);
+		/* 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);
 		}
-	}

-	s = socket(PF_CAN, SOCK_RAW, CAN_RAW);
-	if (s < 0) {
-		perror("socket");
-		return 1;
-	}
+		addr.can_family = AF_CAN;
+		addr.can_ifindex = ifr.ifr_ifindex;

-	/* try to switch the socket into CAN FD mode */
-	const int canfd_on = 1;
-	setsockopt(s, SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &canfd_on, sizeof(canfd_on));
-
-	addr.can_family = AF_CAN;
-	addr.can_ifindex = 0; /* any CAN device */
-
-	if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
-		perror("bind");
-		return 1;
+		if (bind(s[i], (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+			perror("bind");
+			return 1;
+		}
 	}

 	alarm(1);
@ -554,100 +386,43 @@ int main(int argc, char **argv)
 	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);
-		FD_SET(s, &rdfs);
-		FD_SET(STDIN_FILENO, &rdfs);
+		for (i = 0; i < currmax; i++)
+			FD_SET(s[i], &rdfs);

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

-		if (FD_ISSET(STDIN_FILENO, &rdfs)) {
-			if (getchar() == 'r') {
-				reset = true;
+		for (i = 0; i < currmax; i++) { /* check all CAN RAW sockets */
+
+			if (FD_ISSET(s[i], &rdfs)) {
+				nbytes = read(s[i], &frame, sizeof(frame));
+
+				if (nbytes < 0) {
+					perror("read");
+					return 1;
+				}
+
+				if (nbytes < (int)sizeof(struct can_frame)) {
+					fprintf(stderr, "read: incomplete CAN frame\n");
+					return 1;
+				}
+
+				stat[i].recv_frames++;
+				stat[i].recv_bits_payload += frame.len * 8;
+				stat[i].recv_bits_dbitrate += can_frame_dbitrate_length(
+						&frame, mode, sizeof(frame));
+				stat[i].recv_bits_total += can_frame_length(&frame,
+									    mode, nbytes);
 			}
 		}
-
-		/* 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) &&
-		    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(
-			&frame, mode, sizeof(frame));
-		stat[i].recv_bits_total += can_frame_length(&frame,
-							    mode, nbytes);
 	}

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

 	if (signal_num)
 		return 128 + signal_num;
--- a/canerrsim.c
+++ b/canerrsim.c
@ -21,18 +21,20 @@
 //                                                                                                //
 ////////////////////////////////////////////////////////////////////////////////////////////////////

-#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 <ctype.h>
 #include <string.h>
-#include <sys/ioctl.h>
+#include <stdbool.h>
 #include <unistd.h>
+#include <sys/ioctl.h>
+#include <net/if.h>
+#include <stdint.h>
+#include <linux/can.h>
+#include <linux/can/raw.h>
+#include <linux/can/error.h>

+#define can_interface_name argv[1]
 #define STR_EQUAL 0

 void show_help_and_exit()
@ -540,9 +542,9 @@ int main(int argc, char *argv[])
 		err_exit("Error while opening socket");

 	// set interface name
-	strcpy(ifr.ifr_name, argv[1]); // can0, vcan0...
+	strcpy(ifr.ifr_name, can_interface_name); // can0, vcan0...
 	if (ioctl(sock, SIOCGIFINDEX, &ifr) < 0) {
-		sprintf(tmp_str, "Error setting CAN interface name %s", argv[1]);
+		sprintf(tmp_str, "Error setting CAN interface name %s", can_interface_name);
 		err_exit(tmp_str);
 	}

--- 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 0x%x mismatch!\n", i);
+				printf("Databyte %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,7 +189,6 @@ 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");
@ -480,7 +479,6 @@ 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 };
@ -514,7 +512,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:P:n:ixc:vh?", long_options, NULL)) != -1) {
+	while ((opt = getopt_long(argc, argv, "g:atefbEXR8mI:L:D:F:S:A:V:p:n:ixc:vh?", long_options, NULL)) != -1) {
 		switch (opt) {
 		case 'g':
 			gap = strtod(optarg, NULL);
@ -684,14 +682,6 @@ 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;
@ -760,16 +750,6 @@ 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 three bits CANXL_[XLF|SEC|RRS]
+ * The canxl_frame.flags element contains two bits CANXL_XLF and CANXL_SEC
 * 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,7 +192,6 @@ 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,8 +22,6 @@ 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 = libj1939_prepare_for_events(&priv->cmn, &nfds, dont_wait);
+	ret = isobusfs_cmn_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 = libj1939_open_socket();
+	ret = isobusfs_cmn_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 = libj1939_bind_socket(priv->sock_main, &addr);
+	ret = isobusfs_cmn_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 = libj1939_socket_prio(priv->sock_main, ISOBUSFS_PRIO_DEFAULT);
+	ret = isobusfs_cmn_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 libj1939_add_socket_to_epoll(priv->cmn.epoll_fd,
+	return isobusfs_cmn_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 libj1939_add_socket_to_epoll(priv->cmn.epoll_fd,
+	return isobusfs_cmn_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 = libj1939_open_socket();
+	ret = isobusfs_cmn_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 = libj1939_bind_socket(priv->sock_ccm, &addr);
+	ret = isobusfs_cmn_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 = libj1939_socket_prio(priv->sock_ccm, ISOBUSFS_PRIO_DEFAULT);
+	ret = isobusfs_cmn_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 libj1939_add_socket_to_epoll(priv->cmn.epoll_fd, priv->sock_ccm,
+	return isobusfs_cmn_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 = libj1939_open_socket();
+	ret = isobusfs_cmn_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);
+	ret = isobusfs_cmn_bind_socket(priv->sock_nack, &addr);
 	if (ret < 0)
 		return ret;

-	ret = libj1939_socket_prio(priv->sock_nack, ISOBUSFS_PRIO_ACK);
+	ret = isobusfs_cmn_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 libj1939_add_socket_to_epoll(priv->cmn.epoll_fd,
+	return isobusfs_cmn_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 = libj1939_open_socket();
+	ret = isobusfs_cmn_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 = libj1939_bind_socket(priv->sock_bcast_rx, &addr);
+	ret = isobusfs_cmn_bind_socket(priv->sock_bcast_rx, &addr);
 	if (ret < 0)
 		return ret;

-	ret = libj1939_set_broadcast(priv->sock_bcast_rx);
+	ret = isobusfs_cmn_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 libj1939_add_socket_to_epoll(priv->cmn.epoll_fd, priv->sock_bcast_rx,
+	return isobusfs_cmn_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 = libj1939_create_epoll();
+	ret = isobusfs_cmn_create_epoll();
 	if (ret < 0)
 		return ret;

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

 	bzero(priv, sizeof(*priv));

-	libj1939_init_sockaddr_can(&priv->sockname, J1939_NO_PGN);
-	libj1939_init_sockaddr_can(&priv->peername, ISOBUSFS_PGN_CL_TO_FS);
+	isobusfs_init_sockaddr_can(&priv->sockname, J1939_NO_PGN);
+	isobusfs_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 libj1939_cmn cmn;
+	struct isobusfs_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 command\n");
+		pr_int("unknown comand\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 specific dir */
+	/* expected result \\vol1\~\ not clear if it is manufacture speficic dir */
 	{ "\\~\\", true },
 	/* expected result \\~\ */
 	{ "\\\\~\\", false },
--- a/isobusfs/isobusfs_cmn.c
+++ b/isobusfs/isobusfs_cmn.c
@ -125,6 +125,29 @@ 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) {
@ -215,6 +238,15 @@ 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)
 {
@ -488,6 +520,28 @@ 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
@ -596,6 +650,47 @@ 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;
@ -610,8 +705,34 @@ 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 won't to stop sending
+ * but it would be nice to have it. Especially if we wont to stop sending
 * messages on a socket when the connection is lost.
 */
 int isobusfs_cmn_set_linger(int sock)
@ -632,6 +753,70 @@ 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,6 +257,15 @@ 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);

 /*
@ -291,6 +300,7 @@ 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);
@ -303,11 +313,20 @@ 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 access path %s, for read %s. %s", path,
+		pr_err("failed to acces 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 within this
+		 * If a client sends a command, which is not defined withing 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 = libj1939_prepare_for_events(&priv->cmn, &nfds, false);
+	ret = isobusfs_cmn_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 = libj1939_open_socket();
+	ret = isobusfs_cmn_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 */
-	/* TODO: actually, this is PGN input filter. Should we use different
+	/* TOOD: actually, this is PGN input filter. Should we use different
 	 * PGN?
 	 */
 	addr.can_addr.j1939.pgn = ISOBUSFS_PGN_CL_TO_FS;
-	ret = libj1939_bind_socket(priv->sock_fss, &addr);
+	ret = isobusfs_cmn_bind_socket(priv->sock_fss, &addr);
 	if (ret < 0)
 		return ret;

-	ret = libj1939_set_broadcast(priv->sock_fss);
+	ret = isobusfs_cmn_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 = libj1939_socket_prio(priv->sock_fss, ISOBUSFS_PRIO_FSS);
+	ret = isobusfs_cmn_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 libj1939_add_socket_to_epoll(priv->cmn.epoll_fd, priv->sock_fss,
+	return isobusfs_cmn_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 = libj1939_open_socket();
+	ret = isobusfs_cmn_open_socket();
 	if (ret < 0)
 		return ret;

@ -325,12 +325,12 @@ 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 = libj1939_bind_socket(priv->sock_in, &addr);
+	ret = isobusfs_cmn_bind_socket(priv->sock_in, &addr);
 	if (ret < 0)
 		return ret;

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

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

-	ret = libj1939_open_socket();
+	ret = isobusfs_cmn_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);
+	ret = isobusfs_cmn_bind_socket(priv->sock_nack, &addr);
 	if (ret < 0)
 		return ret;

-	ret = libj1939_socket_prio(priv->sock_nack, ISOBUSFS_PRIO_ACK);
+	ret = isobusfs_cmn_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 libj1939_add_socket_to_epoll(priv->cmn.epoll_fd,
-					    priv->sock_nack, EPOLLIN);
+	return isobusfs_cmn_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 = libj1939_create_epoll();
+	ret = isobusfs_cmn_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. Won't be able to generate proper manufacturer-specific directory name. Falling mack to MCMC0000");
+		pr_warn("local name is not set. Wont 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 */
-	libj1939_init_sockaddr_can(&priv->addr, J1939_NO_PGN);
+	isobusfs_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 libj1939_cmn cmn;
+	struct isobusfs_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 = libj1939_open_socket();
+	ret = isobusfs_cmn_open_socket();
 	if (ret < 0)
 		return ret;

 	client->sock = ret;

 	addr.can_addr.j1939.pgn = ISOBUSFS_PGN_CL_TO_FS;
-	ret = libj1939_bind_socket(client->sock, &addr);
+	ret = isobusfs_cmn_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 = libj1939_socket_prio(client->sock, ISOBUSFS_PRIO_DEFAULT);
+	ret = isobusfs_cmn_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 assume, the relative path stored in res->name is not longer
+	 * We assime, 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), read size: %d",
+	pr_debug("> tx: Read File Response. Error code: %d (%s), readed size: %d",
 		 error_code, isobusfs_error_to_str(error_code), readed_size);

 free_res:
--- a/isotpdump.c
+++ b/isotpdump.c
@ -72,7 +72,6 @@ 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");
@ -198,12 +197,11 @@ int main(int argc, char **argv)
 {
 	int s;
 	struct sockaddr_can addr;
-	struct can_filter rfilter[3];
+	struct can_filter rfilter[2];
 	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;
@ -224,7 +222,7 @@ int main(int argc, char **argv)
 	last_tv.tv_sec  = 0;
 	last_tv.tv_usec = 0;

-	while ((opt = getopt(argc, argv, "s:d:b:ax:X:ct:u?")) != -1) {
+	while ((opt = getopt(argc, argv, "s:d:ax:X:ct:u?")) != -1) {
 		switch (opt) {
 		case 's':
 			src = strtoul(optarg, NULL, 16);
@ -238,12 +236,6 @@ 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;
@ -329,18 +321,7 @@ 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]));
+	setsockopt(s, SOL_CAN_RAW, CAN_RAW_FILTER, &rfilter, sizeof(rfilter));

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

-		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 (color)
+			printf("%s", (frame.can_id == src) ? FGRED : FGBLUE);

 		if (timestamp) {
 			ioctl(s, SIOCGSTAMP, &tv);
--- a/j1939_timedate/j1939_timedate_cli.c
+++ b/j1939_timedate/j1939_timedate_cli.c
@ -1,500 +0,0 @@
-// 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
@ -1,84 +0,0 @@
-// 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
@ -1,450 +0,0 @@
-// 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,6 +38,7 @@ 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"
@ -53,13 +54,14 @@ 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:?";
+static const char optstring[] = "vr:c:a:p:?";

 /* byte swap functions */
 static inline int host_is_little_endian(void)
@ -464,6 +466,9 @@ 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) {
@ -479,6 +484,15 @@ 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,6 +97,15 @@ 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)
 {
@ -757,8 +766,8 @@ int main(int argc, char *argv[])
 	priv->polltimeout = 100000;
 	priv->repeat = 1;

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

 	ret = j1939cat_parse_args(priv, argc, argv);
 	if (ret)
--- a/j1939sr.c
+++ b/j1939sr.c
@ -94,6 +94,9 @@ 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,24 +11,19 @@
 */

 #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 <sys/epoll.h>
+
+#include <fcntl.h>
+#include <net/if.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;
@ -200,232 +195,3 @@ 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,12 +13,9 @@
 /* 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
@ -27,30 +24,10 @@
 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,15 +54,6 @@

 #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)
@ -74,17 +65,18 @@ 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 CAN CC)\n");
-	fprintf(stderr, "         -x  (use CANXL format also for CAN CC/FD)\n");
+	fprintf(stderr, "         -f  (use CANFD format also for Classic CAN)\n");
 	fprintf(stderr, "         -r  (suppress dlc for RTR frames - pre v8.5 tools)\n");
 }

-static void can_asc(struct can_frame *cf, int devno, int nortrdlc,
+static void can_asc(struct canfd_frame *cfd, int devno, int nortrdlc,
 		    char *extra_info, FILE *outfile)
 {
-	unsigned int i, dlc;
+	int i;
 	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 */

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

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

 		if (cf->len == CAN_MAX_DLC &&
 		    cf->len8_dlc > CAN_MAX_DLC &&
@ -128,13 +120,19 @@ static void can_asc(struct can_frame *cf, int devno, int nortrdlc,
 static void canfd_asc(struct canfd_frame *cf, int devno, int mtu,
 		      char *extra_info, FILE *outfile)
 {
-	unsigned int i;
+	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 */
@ -142,7 +140,7 @@ static void canfd_asc(struct canfd_frame *cf, int devno, int mtu,
 			dir = "Tx";
 	}

-	fprintf(outfile, "CANFD %3d %-4s ", devno, dir); /* 3 column channel number right aligned */
+	fprintf(outfile, "CANFD %3d %s ", 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':' ');
@ -176,124 +174,13 @@ static void canfd_asc(struct canfd_frame *cf, int devno, int mtu,

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

-	for (i = 0; i < dlen; i++) {
+	for (i = 0; i < (int)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)   ")
@ -318,11 +205,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, xlfmt, nortrdlc, d4, opt, mtu;
+	static int maxdev, devno, i, crlf, fdfmt, nortrdlc, d4, opt, mtu;
 	int print_banner = 1;
 	unsigned long long sec, usec;

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

-		case 'x':
-			xlfmt = 1;
-			break;
-
 		case 'r':
 			nortrdlc = 1;
 			break;
@ -417,9 +300,6 @@ 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++) {
@ -433,8 +313,14 @@ int main(int argc, char **argv)

 			mtu = parse_canframe(afrbuf, &cu);

-			/* no error message frames in non CAN CC frames */
-			if ((mtu != CAN_MTU) && (cu.cc.can_id & CAN_ERR_FLAG))
+			/* 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))
 				continue;

 			tv.tv_sec  = tv.tv_sec - start_tv.tv_sec;
@ -449,12 +335,10 @@ 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) && (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);
+			if ((mtu == CAN_MTU) && (fdfmt == 0))
+				can_asc(&cu.fd, devno, nortrdlc, extra_info, outfile);
 			else
-				canxl_asc(&cu, devno, mtu, extra_info, outfile);
+				canfd_asc(&cu.fd, 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
Marc Kleine-Budde	27b5bef817	canerrsim: main(): add missing () to function calls	2024-05-29 21:16:13 +02:00
Marc Kleine-Budde	b7f158b30f	canerrsim: main(): initialize bool variables	2024-05-29 21:16:13 +02:00
Marc Kleine-Budde	e67e3c675d	canerrsim: show_help_and_exit(): use "%s" to print string	2024-05-29 21:16:13 +02:00
Marc Kleine-Budde	9f73e9c373	canerrsim: clang-format	2024-05-29 21:16:13 +02:00
Marc Kleine-Budde	f012e01c6b	canerrsim: remove trailing whitespace	2024-05-29 21:16:13 +02:00
Marc Kleine-Budde	999aba442d	cmake: add canerrsim	2024-05-29 21:16:10 +02:00
Zeljko Avramovic	98b72d700c	canerrsim: add Link: https://github.com/linux-can/can-utils/issues/525#issue-2311379340	2024-05-29 21:15:26 +02:00