X-Git-Url: http://rtime.felk.cvut.cz/gitweb/can-utils.git/blobdiff_plain/e47a1b4b26673ab7b9783f50366fff8a5300c8b8..HEAD:/candump.c

diff --git a/candump.c b/candump.c
index ce5ca42..c983b71 100644
--- a/candump.c
+++ b/candump.c
@@ -1,11 +1,7 @@
-/*
- *  $Id$
- */
-
 /*
  * candump.c
  *
- * Copyright (c) 2002-2007 Volkswagen Group Electronic Research
+ * Copyright (c) 2002-2009 Volkswagen Group Electronic Research
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -41,18 +37,20 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  * DAMAGE.
  *
- * Send feedback to <socketcan-users@lists.berlios.de>
+ * Send feedback to <linux-can@vger.kernel.org>
  *
  */
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <stdint.h>
 #include <unistd.h>
 #include <string.h>
 #include <signal.h>
 #include <ctype.h>
 #include <libgen.h>
 #include <time.h>
+#include <errno.h>
 
 #include <sys/time.h>
 #include <sys/types.h>
@@ -63,13 +61,25 @@
 
 #include <linux/can.h>
 #include <linux/can/raw.h>
+#include <linux/net_tstamp.h>
 
 #include "terminal.h"
 #include "lib.h"
 
-#define MAXDEV 6 /* change sscanf()'s manually if changed here */
-#define ANYDEV "any"
-#define ANL "\r\n" /* newline in ASC mode */
+#ifndef SIOCSHWTSTAMP
+# define SIOCSHWTSTAMP 0x89b0
+#endif
+
+#define MAXSOCK 16    /* max. number of CAN interfaces given on the cmdline */
+#define MAXIFNAMES 30 /* size of receive name index to omit ioctls */
+#define MAXCOL 6      /* number of different colors for colorized output */
+#define ANYDEV "any"  /* name of interface to receive from any CAN interface */
+#define ANL "\r\n"    /* newline in ASC mode */
+
+#define SILENT_INI 42 /* detect user setting on commandline */
+#define SILENT_OFF 0  /* no silent mode */
+#define SILENT_ANI 1  /* silent mode with animation */
+#define SILENT_ON  2  /* silent mode (completely silent) */
 
 #define BOLD    ATTBOLD
 #define RED     ATTBOLD FGRED
@@ -79,15 +89,20 @@
 #define MAGENTA ATTBOLD FGMAGENTA
 #define CYAN    ATTBOLD FGCYAN
 
-const char col_on [MAXDEV][19] = {BLUE, RED, GREEN, BOLD, MAGENTA, CYAN};
+const char col_on [MAXCOL][19] = {BLUE, RED, GREEN, BOLD, MAGENTA, CYAN};
 const char col_off [] = ATTRESET;
 
-static char devname[MAXDEV][IFNAMSIZ+1];
-static int  dindex[MAXDEV];
-static int  max_devname_len;
+static char *cmdlinename[MAXSOCK];
+static __u32 dropcnt[MAXSOCK];
+static __u32 last_dropcnt[MAXSOCK];
+static char devname[MAXIFNAMES][IFNAMSIZ+1];
+static int  dindex[MAXIFNAMES];
+static int  max_devname_len; /* to prevent frazzled device name output */ 
+const int canfd_on = 1;
 
-#define MAXANI 8
-const char anichar[MAXANI] = {'|', '/', '-', '\\', '|', '/', '-', '\\'};
+#define MAXANI 4
+const char anichar[MAXANI] = {'|', '/', '-', '\\'};
+const char extra_m_info[4][4] = {"- -", "B -", "- E", "B E"};
 
 extern int optind, opterr, optopt;
 
@@ -95,467 +110,744 @@ static volatile int running = 1;
 
 void print_usage(char *prg)
 {
-    fprintf(stderr, "Usage: %s [can-interfaces]\n", prg);
-    fprintf(stderr, "  (use CTRL-C to terminate %s)\n", prg);
-    fprintf(stderr, "Options: -m <mask>   (default 0x00000000)\n");
-    fprintf(stderr, "         -v <value>  (default 0x00000000)\n");
-    fprintf(stderr, "         -i <0|1>    (inv_filter)\n");
-    fprintf(stderr, "         -e <emask>  (mask for error frames)\n");
-    fprintf(stderr, "         -t <type>   (timestamp: Absolute/Delta/Zero)\n");
-    fprintf(stderr, "         -c          (color mode)\n");
-    fprintf(stderr, "         -a          (enable additional ASCII output)\n");
-    fprintf(stderr, "         -s <level>  (silent mode - 1: animation 2: nothing)\n");
-    fprintf(stderr, "         -b <can>    (bridge mode - send received frames to <can>)\n");
-    fprintf(stderr, "         -B <can>    (bridge mode - like '-b' with disabled loopback)\n");
-    fprintf(stderr, "         -l          (log CAN-frames into file)\n");
-    fprintf(stderr, "         -L          (use log file format on stdout)\n");
-    fprintf(stderr, "\n");
-    fprintf(stderr, "When using more than one CAN interface the options\n");
-    fprintf(stderr, "m/v/i/e have comma seperated values e.g. '-m 0,7FF,0'\n");
-    fprintf(stderr, "Use interface name '%s' to receive from all can-interfaces\n", ANYDEV);
+	fprintf(stderr, "\nUsage: %s [options] <CAN interface>+\n", prg);
+	fprintf(stderr, "  (use CTRL-C to terminate %s)\n\n", prg);
+	fprintf(stderr, "Options: -t <type>   (timestamp: (a)bsolute/(d)elta/(z)ero/(A)bsolute w date)\n");
+	fprintf(stderr, "         -H          (use hardware timestamping)\n");
+	fprintf(stderr, "         -c          (increment color mode level)\n");
+	fprintf(stderr, "         -i          (binary output - may exceed 80 chars/line)\n");
+	fprintf(stderr, "         -a          (enable additional ASCII output)\n");
+	fprintf(stderr, "         -S          (swap byte order in printed CAN data[] - marked with '%c' )\n", SWAP_DELIMITER);
+	fprintf(stderr, "         -s <level>  (silent mode - %d: off (default) %d: animation %d: silent)\n", SILENT_OFF, SILENT_ANI, SILENT_ON);
+	fprintf(stderr, "         -b <can>    (bridge mode - send received frames to <can>)\n");
+	fprintf(stderr, "         -B <can>    (bridge mode - like '-b' with disabled loopback)\n");
+	fprintf(stderr, "         -u <usecs>  (delay bridge forwarding by <usecs> microseconds)\n");
+	fprintf(stderr, "         -l          (log CAN-frames into file. Sets '-s %d' by default)\n", SILENT_ON);
+	fprintf(stderr, "         -L          (use log file format on stdout)\n");
+	fprintf(stderr, "         -n <count>  (terminate after receiption of <count> CAN frames)\n");
+	fprintf(stderr, "         -r <size>   (set socket receive buffer to <size>)\n");
+	fprintf(stderr, "         -d          (monitor dropped CAN frames)\n");
+	fprintf(stderr, "         -e          (dump CAN error frames in human-readable format)\n");
+	fprintf(stderr, "         -x          (print extra message infos, rx/tx brs esi)\n");
+	fprintf(stderr, "         -T <msecs>  (terminate after <msecs> without any reception)\n");
+	fprintf(stderr, "\n");
+	fprintf(stderr, "Up to %d CAN interfaces with optional filter sets can be specified\n", MAXSOCK);
+	fprintf(stderr, "on the commandline in the form: <ifname>[,filter]*\n");
+	fprintf(stderr, "\nComma separated filters can be specified for each given CAN interface:\n");
+	fprintf(stderr, " <can_id>:<can_mask> (matches when <received_can_id> & mask == can_id & mask)\n");
+	fprintf(stderr, " <can_id>~<can_mask> (matches when <received_can_id> & mask != can_id & mask)\n");
+	fprintf(stderr, " #<error_mask>       (set error frame filter, see include/linux/can/error.h)\n");
+	fprintf(stderr, " [j|J]               (join the given CAN filters - logical AND semantic)\n");
+	fprintf(stderr, "\nCAN IDs, masks and data content are given and expected in hexadecimal values.\n");
+	fprintf(stderr, "When can_id and can_mask are both 8 digits, they are assumed to be 29 bit EFF.\n");
+	fprintf(stderr, "Without any given filter all data frames are received ('0:0' default filter).\n");
+	fprintf(stderr, "\nUse interface name '%s' to receive from all CAN interfaces.\n", ANYDEV);
+	fprintf(stderr, "\nExamples:\n");
+	fprintf(stderr, "%s -c -c -ta can0,123:7FF,400:700,#000000FF can2,400~7F0 can3 can8\n", prg);
+	fprintf(stderr, "%s -l any,0~0,#FFFFFFFF    (log only error frames but no(!) data frames)\n", prg);
+	fprintf(stderr, "%s -l any,0:0,#FFFFFFFF    (log error frames and also all data frames)\n", prg);
+	fprintf(stderr, "%s vcan2,92345678:DFFFFFFF (match only for extended CAN ID 12345678)\n", prg);
+	fprintf(stderr, "%s vcan2,123:7FF (matches CAN ID 123 - including EFF and RTR frames)\n", prg);
+	fprintf(stderr, "%s vcan2,123:C00007FF (matches CAN ID 123 - only SFF and non-RTR frames)\n", prg);
+	fprintf(stderr, "\n");
 }
 
 void sigterm(int signo)
 {
-    running = 0;
+	running = 0;
 }
 
 int idx2dindex(int ifidx, int socket) {
 
-    int i;
-    struct ifreq ifr;
+	int i;
+	struct ifreq ifr;
 
-    for (i=0; i<MAXDEV; i++) {
-	if (dindex[i] == ifidx)
-	    return i;
-    }
+	for (i=0; i < MAXIFNAMES; i++) {
+		if (dindex[i] == ifidx)
+			return i;
+	}
 
-    /* create new interface index cache entry */
+	/* create new interface index cache entry */
 
-    /* remove index cache zombies first */
-    for (i=0; i < MAXDEV; i++) {
-	if (dindex[i]) {
-	    ifr.ifr_ifindex = dindex[i];
-	    if (ioctl(socket, SIOCGIFNAME, &ifr) < 0)
-		dindex[i] = 0;
+	/* remove index cache zombies first */
+	for (i=0; i < MAXIFNAMES; i++) {
+		if (dindex[i]) {
+			ifr.ifr_ifindex = dindex[i];
+			if (ioctl(socket, SIOCGIFNAME, &ifr) < 0)
+				dindex[i] = 0;
+		}
 	}
-    }
 
-    for (i=0; i < MAXDEV; i++)
-	if (!dindex[i]) /* free entry */
-	    break;
+	for (i=0; i < MAXIFNAMES; i++)
+		if (!dindex[i]) /* free entry */
+			break;
 
-    if (i == MAXDEV) {
-	printf("Interface index cache only supports %d interfaces.\n", MAXDEV);
-	exit(1);
-    }
+	if (i == MAXIFNAMES) {
+		fprintf(stderr, "Interface index cache only supports %d interfaces.\n",
+		       MAXIFNAMES);
+		exit(1);
+	}
 
-    dindex[i] = ifidx;
+	dindex[i] = ifidx;
 
-    ifr.ifr_ifindex = ifidx;
-    if (ioctl(socket, SIOCGIFNAME, &ifr) < 0)
-	perror("SIOCGIFNAME");
+	ifr.ifr_ifindex = ifidx;
+	if (ioctl(socket, SIOCGIFNAME, &ifr) < 0)
+		perror("SIOCGIFNAME");
 
-    if (max_devname_len < strlen(ifr.ifr_name))
-	max_devname_len = strlen(ifr.ifr_name);
+	if (max_devname_len < strlen(ifr.ifr_name))
+		max_devname_len = strlen(ifr.ifr_name);
 
-    strcpy(devname[i], ifr.ifr_name);
+	strcpy(devname[i], ifr.ifr_name);
 
 #ifdef DEBUG
-    printf("new index %d (%s)\n", i, devname[i]);
+	printf("new index %d (%s)\n", i, devname[i]);
 #endif
 
-    return i;
+	return i;
 }
 
 int main(int argc, char **argv)
 {
-    fd_set rdfs;
-    int s[MAXDEV];
-    int bridge = 0;
-    canid_t mask[MAXDEV] = {0};
-    canid_t value[MAXDEV] = {0};
-    int inv_filter[MAXDEV] = {0};
-    can_err_mask_t err_mask[MAXDEV] = {0};
-    unsigned char timestamp = 0;
-    unsigned char silent = 0;
-    unsigned char silentani = 0;
-    unsigned char color = 0;
-    unsigned char ascii = 0;
-    unsigned char log = 0;
-    unsigned char logfrmt = 0;
-    int opt, ret;
-    int currmax = 1; /* we assume at least one can bus ;-) */
-    struct sockaddr_can addr;
-    struct can_filter rfilter;
-    struct can_frame frame;
-    int nbytes, i, j;
-    struct ifreq ifr;
-    struct timeval tv, last_tv;
-    FILE *logfile = NULL;
-
-    signal(SIGTERM, sigterm);
-    signal(SIGHUP, sigterm);
-    signal(SIGINT, sigterm);
-
-    last_tv.tv_sec  = 0;
-    last_tv.tv_usec = 0;
-
-    while ((opt = getopt(argc, argv, "m:v:i:e:t:cas:b:B:lL")) != -1) {
-	switch (opt) {
-	case 'm':
-	    i = sscanf(optarg, "%x,%x,%x,%x,%x,%x",
-		       &mask[0], &mask[1], &mask[2],
-		       &mask[3], &mask[4], &mask[5]);
-	    if (i > currmax)
-		currmax = i;
-	    break;
-
-	case 'v':
-	    i = sscanf(optarg, "%x,%x,%x,%x,%x,%x",
-		       &value[0], &value[1], &value[2],
-		       &value[3], &value[4], &value[5]);
-	    if (i > currmax)
-		currmax = i;
-	    break;
-
-	case 'i':
-	    i = sscanf(optarg, "%d,%d,%d,%d,%d,%d",
-		       &inv_filter[0], &inv_filter[1], &inv_filter[2],
-		       &inv_filter[3], &inv_filter[4], &inv_filter[5]);
-	    if (i > currmax)
-		currmax = i;
-	    break;
-
-	case 'e':
-	    i = sscanf(optarg, "%x,%x,%x,%x,%x,%x",
-		       &err_mask[0], &err_mask[1], &err_mask[2],
-		       &err_mask[3], &err_mask[4], &err_mask[5]);
-	    if (i > currmax)
-		currmax = i;
-	    break;
-
-	case 't':
-	    timestamp = optarg[0];
-	    if ((timestamp != 'a') && (timestamp != 'A') &&
-		(timestamp != 'd') && (timestamp != 'z')) {
-		printf("%s: unknown timestamp mode '%c' - ignored\n",
-		       basename(argv[0]), optarg[0]);
-		timestamp = 0;
-	    }
-	    break;
-
-	case 'c':
-	    color++;
-	    break;
-
-	case 'a':
-	    ascii = 1;
-	    break;
-
-	case 's':
-	    silent = atoi(optarg);
-	    break;
-
-	case 'b':
-	case 'B':
-	    if (strlen(optarg) >= IFNAMSIZ) {
-		printf("Name of CAN device '%s' is too long!\n\n", optarg);
-		return 1;
-	    }
-	    else {
-		if ((bridge = socket(PF_CAN, SOCK_RAW, CAN_RAW)) < 0) {
-		    perror("bridge socket");
-		    return 1;
-		}
-		addr.can_family = AF_CAN;
-		strcpy(ifr.ifr_name, optarg);
-		if (ioctl(bridge, SIOCGIFINDEX, &ifr) < 0)
-		    perror("SIOCGIFINDEX");
-		addr.can_ifindex = ifr.ifr_ifindex;
+	fd_set rdfs;
+	int s[MAXSOCK];
+	int bridge = 0;
+	useconds_t bridge_delay = 0;
+	unsigned char timestamp = 0;
+	int hw_timestamp = 0;
+	unsigned char dropmonitor = 0;
+	unsigned char extra_msg_info = 0;
+	unsigned char silent = SILENT_INI;
+	unsigned char silentani = 0;
+	unsigned char color = 0;
+	unsigned char view = 0;
+	unsigned char log = 0;
+	unsigned char logfrmt = 0;
+	int count = 0;
+	int rcvbuf_size = 0;
+	int opt, ret;
+	int currmax, numfilter;
+	int join_filter;
+	char *ptr, *nptr;
+	struct sockaddr_can addr;
+	char ctrlmsg[CMSG_SPACE(sizeof(struct timeval)) + CMSG_SPACE(sizeof(__u32))];
+	struct iovec iov;
+	struct msghdr msg;
+	struct cmsghdr *cmsg;
+	struct can_filter *rfilter;
+	can_err_mask_t err_mask;
+	struct canfd_frame frame;
+	int nbytes, i, maxdlen;
+	struct ifreq ifr;
+	struct timeval tv, last_tv;
+	struct timeval timeout, timeout_config = { 0, 0 }, *timeout_current = NULL;
+	FILE *logfile = NULL;
+
+	signal(SIGTERM, sigterm);
+	signal(SIGHUP, sigterm);
+	signal(SIGINT, sigterm);
+
+	last_tv.tv_sec  = 0;
+	last_tv.tv_usec = 0;
+
+	while ((opt = getopt(argc, argv, "t:ciaSs:b:B:u:ldxLn:r:heT:H?")) != -1) {
+		switch (opt) {
+		case 't':
+			timestamp = optarg[0];
+			if ((timestamp != 'a') && (timestamp != 'A') &&
+			    (timestamp != 'd') && (timestamp != 'z')) {
+				fprintf(stderr, "%s: unknown timestamp mode '%c' - ignored\n",
+				       basename(argv[0]), optarg[0]);
+				timestamp = 0;
+			}
+			break;
+
+		case 'H':
+			hw_timestamp = 1;
+			break;
+
+		case 'c':
+			color++;
+			break;
+
+		case 'i':
+			view |= CANLIB_VIEW_BINARY;
+			break;
+
+		case 'a':
+			view |= CANLIB_VIEW_ASCII;
+			break;
+
+		case 'S':
+			view |= CANLIB_VIEW_SWAP;
+			break;
+
+		case 'e':
+			view |= CANLIB_VIEW_ERROR;
+			break;
+
+		case 's':
+			silent = atoi(optarg);
+			if (silent > SILENT_ON) {
+				print_usage(basename(argv[0]));
+				exit(1);
+			}
+			break;
+
+		case 'b':
+		case 'B':
+			if (strlen(optarg) >= IFNAMSIZ) {
+				fprintf(stderr, "Name of CAN device '%s' is too long!\n\n", optarg);
+				return 1;
+			} else {
+				bridge = socket(PF_CAN, SOCK_RAW, CAN_RAW);
+				if (bridge < 0) {
+					perror("bridge socket");
+					return 1;
+				}
+				addr.can_family = AF_CAN;
+				strcpy(ifr.ifr_name, optarg);
+				if (ioctl(bridge, SIOCGIFINDEX, &ifr) < 0)
+					perror("SIOCGIFINDEX");
+				addr.can_ifindex = ifr.ifr_ifindex;
 		
-		if (!addr.can_ifindex) {
-		    perror("invalid bridge interface");
-		    return 1;
+				if (!addr.can_ifindex) {
+					perror("invalid bridge interface");
+					return 1;
+				}
+
+				/* disable default receive filter on this write-only RAW socket */
+				setsockopt(bridge, SOL_CAN_RAW, CAN_RAW_FILTER, NULL, 0);
+
+				if (opt == 'B') {
+					const int loopback = 0;
+
+					setsockopt(bridge, SOL_CAN_RAW, CAN_RAW_LOOPBACK,
+						   &loopback, sizeof(loopback));
+				}
+
+				if (bind(bridge, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+					perror("bridge bind");
+					return 1;
+				}
+			}
+			break;
+	    
+		case 'u':
+			bridge_delay = (useconds_t)strtoul(optarg, (char **)NULL, 10);
+			break;
+
+		case 'l':
+			log = 1;
+			break;
+
+		case 'd':
+			dropmonitor = 1;
+			break;
+
+		case 'x':
+			extra_msg_info = 1;
+			break;
+
+		case 'L':
+			logfrmt = 1;
+			break;
+
+		case 'n':
+			count = atoi(optarg);
+			if (count < 1) {
+				print_usage(basename(argv[0]));
+				exit(1);
+			}
+			break;
+
+		case 'r':
+			rcvbuf_size = atoi(optarg);
+			if (rcvbuf_size < 1) {
+				print_usage(basename(argv[0]));
+				exit(1);
+			}
+			break;
+
+		case 'T':
+			errno = 0;
+			timeout_config.tv_usec = strtol(optarg, NULL, 0);
+			if (errno != 0) {
+				print_usage(basename(argv[0]));
+				exit(1);
+			}
+			timeout_config.tv_sec = timeout_config.tv_usec / 1000;
+			timeout_config.tv_usec = (timeout_config.tv_usec % 1000) * 1000;
+			timeout_current = &timeout;
+			break;
+		default:
+			print_usage(basename(argv[0]));
+			exit(1);
+			break;
 		}
+	}
 
-		if (opt == 'B') {
-		    int loopback = 0;
-
-		    setsockopt(bridge, SOL_CAN_RAW, CAN_RAW_LOOPBACK, &loopback, sizeof(loopback));
-		}
+	if (optind == argc) {
+		print_usage(basename(argv[0]));
+		exit(0);
+	}
+	
+	if (logfrmt && view) {
+		fprintf(stderr, "Log file format selected: Please disable ASCII/BINARY/SWAP options!\n");
+		exit(0);
+	}
 
-		if (bind(bridge, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
-		    perror("bridge bind");
-		    return 1;
-		}
-	    }
-	    break;
-	    
-	case 'l':
-	    log = 1;
-	    break;
-
-	case 'L':
-	    logfrmt = 1;
-	    break;
-
-	default:
-	    fprintf(stderr, "Unknown option %c\n", opt);
-	    print_usage(basename(argv[0]));
-	    exit(1);
-	    break;
+	if (silent == SILENT_INI) {
+		if (log) {
+			fprintf(stderr, "Disabled standard output while logging.\n");
+			silent = SILENT_ON; /* disable output on stdout */
+		} else
+			silent = SILENT_OFF; /* default output */
 	}
-    }
 
-    if (optind == argc) {
-	print_usage(basename(argv[0]));
-	exit(0);
-    }
-	
-    /* count in options higher than device count ? */
-    if (optind + currmax > argc) {
-	printf("low count of CAN devices!\n");
-	return 1;
-    }
+	currmax = argc - optind; /* find real number of CAN devices */
 
-    currmax = argc - optind; /* find real number of CAN devices */
+	if (currmax > MAXSOCK) {
+		fprintf(stderr, "More than %d CAN devices given on commandline!\n", MAXSOCK);
+		return 1;
+	}
 
-    if (currmax > MAXDEV) {
-	printf("More than %d CAN devices!\n", MAXDEV);
-	return 1;
-    }
+	for (i=0; i < currmax; i++) {
 
-    for (i=0; i<currmax; i++) {
+		ptr = argv[optind+i];
+		nptr = strchr(ptr, ',');
 
 #ifdef DEBUG
-	printf("open %d '%s' m%08X v%08X i%d e%d.\n",
-	       i, argv[optind+i], mask[i], value[i],
-	       inv_filter[i], err_mask[i]);
+		printf("open %d '%s'.\n", i, ptr);
 #endif
 
-	if ((s[i] = socket(PF_CAN, SOCK_RAW, CAN_RAW)) < 0) {
-	    perror("socket");
-	    return 1;
-	}
+		s[i] = socket(PF_CAN, SOCK_RAW, CAN_RAW);
+		if (s[i] < 0) {
+			perror("socket");
+			return 1;
+		}
 
-	if (mask[i] || value[i]) {
+		cmdlinename[i] = ptr; /* save pointer to cmdline name of this socket */
 
-	    printf("CAN ID filter[%d] for %s set to "
-		   "mask = %08X, value = %08X %s\n",
-		   i, argv[optind+i], mask[i], value[i],
-		   (inv_filter[i]) ? "(inv_filter)" : "");
+		if (nptr)
+			nbytes = nptr - ptr;  /* interface name is up the first ',' */
+		else
+			nbytes = strlen(ptr); /* no ',' found => no filter definitions */
 
-	    rfilter.can_id   = value[i];
-	    rfilter.can_mask = mask[i];
-	    if (inv_filter[i])
-		rfilter.can_id |= CAN_INV_FILTER;
+		if (nbytes >= IFNAMSIZ) {
+			fprintf(stderr, "name of CAN device '%s' is too long!\n", ptr);
+			return 1;
+		}
 
-	    setsockopt(s[i], SOL_CAN_RAW, CAN_RAW_FILTER,
-		       &rfilter, sizeof(rfilter));
-	}
+		if (nbytes > max_devname_len)
+			max_devname_len = nbytes; /* for nice printing */
 
-	if (err_mask[i])
-	    setsockopt(s[i], SOL_CAN_RAW, CAN_RAW_ERR_FILTER,
-		       &err_mask[i], sizeof(err_mask[i]));
+		addr.can_family = AF_CAN;
 
-	j = strlen(argv[optind+i]);
+		memset(&ifr.ifr_name, 0, sizeof(ifr.ifr_name));
+		strncpy(ifr.ifr_name, ptr, nbytes);
 
-	if (!(j < IFNAMSIZ)) {
-	    printf("name of CAN device '%s' is too long!\n", argv[optind+i]);
-	    return 1;
-	}
+#ifdef DEBUG
+		printf("using interface name '%s'.\n", ifr.ifr_name);
+#endif
 
-	if (j > max_devname_len)
-	    max_devname_len = j; /* for nice printing */
+		if (strcmp(ANYDEV, ifr.ifr_name)) {
+			if (ioctl(s[i], SIOCGIFINDEX, &ifr) < 0) {
+				perror("SIOCGIFINDEX");
+				exit(1);
+			}
+			addr.can_ifindex = ifr.ifr_ifindex;
+		} else
+			addr.can_ifindex = 0; /* any can interface */
+
+		if (nptr) {
+
+			/* found a ',' after the interface name => check for filters */
+
+			/* determine number of filters to alloc the filter space */
+			numfilter = 0;
+			ptr = nptr;
+			while (ptr) {
+				numfilter++;
+				ptr++; /* hop behind the ',' */
+				ptr = strchr(ptr, ','); /* exit condition */
+			}
+
+			rfilter = malloc(sizeof(struct can_filter) * numfilter);
+			if (!rfilter) {
+				fprintf(stderr, "Failed to create filter space!\n");
+				return 1;
+			}
+
+			numfilter = 0;
+			err_mask = 0;
+			join_filter = 0;
+
+			while (nptr) {
+
+				ptr = nptr+1; /* hop behind the ',' */
+				nptr = strchr(ptr, ','); /* update exit condition */
+
+				if (sscanf(ptr, "%x:%x",
+					   &rfilter[numfilter].can_id, 
+					   &rfilter[numfilter].can_mask) == 2) {
+ 					rfilter[numfilter].can_mask &= ~CAN_ERR_FLAG;
+					numfilter++;
+				} else if (sscanf(ptr, "%x~%x",
+						  &rfilter[numfilter].can_id, 
+						  &rfilter[numfilter].can_mask) == 2) {
+ 					rfilter[numfilter].can_id |= CAN_INV_FILTER;
+ 					rfilter[numfilter].can_mask &= ~CAN_ERR_FLAG;
+					numfilter++;
+				} else if (*ptr == 'j' || *ptr == 'J') {
+					join_filter = 1;
+				} else if (sscanf(ptr, "#%x", &err_mask) != 1) { 
+					fprintf(stderr, "Error in filter option parsing: '%s'\n", ptr);
+					return 1;
+				}
+			}
+
+			if (err_mask)
+				setsockopt(s[i], SOL_CAN_RAW, CAN_RAW_ERR_FILTER,
+					   &err_mask, sizeof(err_mask));
+
+			if (join_filter && setsockopt(s[i], SOL_CAN_RAW, CAN_RAW_JOIN_FILTERS,
+						      &join_filter, sizeof(join_filter)) < 0) {
+				perror("setsockopt CAN_RAW_JOIN_FILTERS not supported by your Linux Kernel");
+				return 1;
+			}
+
+			if (numfilter)
+				setsockopt(s[i], SOL_CAN_RAW, CAN_RAW_FILTER,
+					   rfilter, numfilter * sizeof(struct can_filter));
+
+			free(rfilter);
+
+		} /* if (nptr) */
+
+		/* try to switch the socket into CAN FD mode */
+		setsockopt(s[i], SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &canfd_on, sizeof(canfd_on));
+
+		if (rcvbuf_size) {
+
+			int curr_rcvbuf_size;
+			socklen_t curr_rcvbuf_size_len = sizeof(curr_rcvbuf_size);
+
+			/* try SO_RCVBUFFORCE first, if we run with CAP_NET_ADMIN */
+			if (setsockopt(s[i], SOL_SOCKET, SO_RCVBUFFORCE,
+				       &rcvbuf_size, sizeof(rcvbuf_size)) < 0) {
+#ifdef DEBUG
+				printf("SO_RCVBUFFORCE failed so try SO_RCVBUF ...\n");
+#endif
+				if (setsockopt(s[i], SOL_SOCKET, SO_RCVBUF,
+					       &rcvbuf_size, sizeof(rcvbuf_size)) < 0) {
+					perror("setsockopt SO_RCVBUF");
+					return 1;
+				}
+
+				if (getsockopt(s[i], SOL_SOCKET, SO_RCVBUF,
+					       &curr_rcvbuf_size, &curr_rcvbuf_size_len) < 0) {
+					perror("getsockopt SO_RCVBUF");
+					return 1;
+				}
+
+				/* Only print a warning the first time we detect the adjustment */
+				/* n.b.: The wanted size is doubled in Linux in net/sore/sock.c */
+				if (!i && curr_rcvbuf_size < rcvbuf_size*2)
+					fprintf(stderr, "The socket receive buffer size was "
+						"adjusted due to /proc/sys/net/core/rmem_max.\n");
+			}
+		}
 
-	addr.can_family = AF_CAN;
+		if (timestamp || log || logfrmt) {
+			if (hw_timestamp == 0) {
+				const int timestamp_on = 1;
+
+				if (setsockopt(s[i], SOL_SOCKET, SO_TIMESTAMP,
+					       &timestamp_on, sizeof(timestamp_on)) < 0) {
+					perror("setsockopt SO_TIMESTAMP");
+					return 1;
+				}
+			} else {
+				struct ifreq hwtstamp;
+				struct hwtstamp_config hwconfig;
+
+				memset(&hwtstamp, 0, sizeof(hwtstamp));
+				strncpy(hwtstamp.ifr_name, ifr.ifr_name, sizeof(hwtstamp.ifr_name));
+				hwtstamp.ifr_data = (void *)&hwconfig;
+				memset(&hwconfig, 0, sizeof(hwconfig));
+				hwconfig.tx_type = HWTSTAMP_TX_OFF;
+				hwconfig.rx_filter = HWTSTAMP_FILTER_ALL;
+
+				if (ioctl(s[i], SIOCSHWTSTAMP, &hwtstamp) < 0) {
+					perror("SIOCSHWTSTAMP");
+					return 1;
+				}
+
+				const int so_timestamping_flags = SOF_TIMESTAMPING_RAW_HARDWARE;
+
+				if (setsockopt(s[i], SOL_SOCKET, SO_TIMESTAMPING,
+					       &so_timestamping_flags,
+					       sizeof(so_timestamping_flags)) < 0)
+					perror("setsockopt SO_TIMESTAMPING");
+			}
+		}
 
-	if (strcmp(ANYDEV, argv[optind+i])) {
-	    strcpy(ifr.ifr_name, argv[optind+i]);
-	    if (ioctl(s[i], SIOCGIFINDEX, &ifr) < 0) {
-		perror("SIOCGIFINDEX");
-		exit(1);
-	    }
-	    addr.can_ifindex = ifr.ifr_ifindex;
-	}
-	else
-	    addr.can_ifindex = 0; /* any can interface */
+		if (dropmonitor) {
 
-	if (bind(s[i], (struct sockaddr *)&addr, sizeof(addr)) < 0) {
-	    perror("bind");
-	    return 1;
-	}
-    }
+			const int dropmonitor_on = 1;
 
-    if (log) {
-	time_t currtime;
-	struct tm now;
-	char fname[sizeof("candump-2006-11-20_202026.log")+1];
+			if (setsockopt(s[i], SOL_SOCKET, SO_RXQ_OVFL,
+				       &dropmonitor_on, sizeof(dropmonitor_on)) < 0) {
+				perror("setsockopt SO_RXQ_OVFL not supported by your Linux Kernel");
+				return 1;
+			}
+		}
 
-	if (time(&currtime) == (time_t)-1) {
-	    perror("time");
-	    return 1;
+		if (bind(s[i], (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+			perror("bind");
+			return 1;
+		}
 	}
 
-	localtime_r(&currtime, &now);
+	if (log) {
+		time_t currtime;
+		struct tm now;
+		char fname[sizeof("candump-2006-11-20_202026.log")+1];
 
-	sprintf(fname, "candump-%04d-%02d-%02d_%02d%02d%02d.log",
-	       now.tm_year + 1900,
-	       now.tm_mon + 1,
-	       now.tm_mday,
-	       now.tm_hour,
-	       now.tm_min,
-	       now.tm_sec);
+		if (time(&currtime) == (time_t)-1) {
+			perror("time");
+			return 1;
+		}
 
-	printf("\nEnabling Logfile '%s'\n\n", fname);
+		localtime_r(&currtime, &now);
 
-	logfile = fopen(fname, "w");
-	if (!logfile) {
-	    perror("logfile");
-	    return 1;
-	}
-    }
+		sprintf(fname, "candump-%04d-%02d-%02d_%02d%02d%02d.log",
+			now.tm_year + 1900,
+			now.tm_mon + 1,
+			now.tm_mday,
+			now.tm_hour,
+			now.tm_min,
+			now.tm_sec);
 
-    while (running) {
+		if (silent != SILENT_ON)
+			printf("\nWarning: console output active while logging!");
 
-	FD_ZERO(&rdfs);
-	for (i=0; i<currmax; i++)
-	    FD_SET(s[i], &rdfs);
+		fprintf(stderr, "\nEnabling Logfile '%s'\n\n", fname);
 
-	if ((ret = select(s[currmax-1]+1, &rdfs, NULL, NULL, NULL)) < 0) {
-	    //perror("select");
-	    running = 0;
-	    continue;
+		logfile = fopen(fname, "w");
+		if (!logfile) {
+			perror("logfile");
+			return 1;
+		}
 	}
 
-	for (i=0; i<currmax; i++) {  /* check all CAN RAW sockets */
+	/* 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 = &ctrlmsg;
 
-	    if (FD_ISSET(s[i], &rdfs)) {
+	while (running) {
 
-		socklen_t len = sizeof(addr);
-		int idx;
+		FD_ZERO(&rdfs);
+		for (i=0; i<currmax; i++)
+			FD_SET(s[i], &rdfs);
 
-		if ((nbytes = recvfrom(s[i], &frame,
-				       sizeof(struct can_frame), 0,
-				       (struct sockaddr*)&addr, &len)) < 0) {
-		    perror("read");
-		    return 1;
-		}
+		if (timeout_current)
+			*timeout_current = timeout_config;
 
-		if (nbytes < sizeof(struct can_frame)) {
-		    fprintf(stderr, "read: incomplete CAN frame\n");
-		    return 1;
+		if ((ret = select(s[currmax-1]+1, &rdfs, NULL, NULL, timeout_current)) <= 0) {
+			//perror("select");
+			running = 0;
+			continue;
 		}
 
-		if (bridge) {
-		    if ((nbytes = write(bridge, &frame,
-					sizeof(struct can_frame))) < 0) {
-			perror("bridge write");
-			return 1;
-		    } else if (nbytes < sizeof(struct can_frame)) {
-			fprintf(stderr,"bridge write: incomplete CAN frame\n");
-			return 1;
-		    }
-		}
+		for (i=0; i<currmax; i++) {  /* check all CAN RAW sockets */
+
+			if (FD_ISSET(s[i], &rdfs)) {
+
+				int idx;
+
+				/* these settings may be modified by recvmsg() */
+				iov.iov_len = sizeof(frame);
+				msg.msg_namelen = sizeof(addr);
+				msg.msg_controllen = sizeof(ctrlmsg);  
+				msg.msg_flags = 0;
+
+				nbytes = recvmsg(s[i], &msg, 0);
+				if (nbytes < 0) {
+					perror("read");
+					return 1;
+				}
+
+				if ((size_t)nbytes == CAN_MTU)
+					maxdlen = CAN_MAX_DLEN;
+				else if ((size_t)nbytes == CANFD_MTU)
+					maxdlen = CANFD_MAX_DLEN;
+				else {
+					fprintf(stderr, "read: incomplete CAN frame\n");
+					return 1;
+				}
+
+				if (count && (--count == 0))
+					running = 0;
+
+				if (bridge) {
+					if (bridge_delay)
+						usleep(bridge_delay);
+
+					nbytes = write(bridge, &frame, nbytes);
+					if (nbytes < 0) {
+						perror("bridge write");
+						return 1;
+					} else if ((size_t)nbytes != CAN_MTU && (size_t)nbytes != CANFD_MTU) {
+						fprintf(stderr,"bridge write: incomplete CAN frame\n");
+						return 1;
+					}
+				}
 		    
-		if (timestamp || log || logfrmt)
-		    if (ioctl(s[i], SIOCGSTAMP, &tv) < 0)
-			perror("SIOCGSTAMP");
+				for (cmsg = CMSG_FIRSTHDR(&msg);
+				     cmsg && (cmsg->cmsg_level == SOL_SOCKET);
+				     cmsg = CMSG_NXTHDR(&msg,cmsg)) {
+					if (cmsg->cmsg_type == SO_TIMESTAMP)
+						tv = *(struct timeval *)CMSG_DATA(cmsg);
+					else if (cmsg->cmsg_type == SO_RXQ_OVFL)
+						dropcnt[i] = *(__u32 *)CMSG_DATA(cmsg);
+					else if (cmsg->cmsg_type == SO_TIMESTAMPING) {
+						struct timespec *ts = (struct timespec *) CMSG_DATA(cmsg);
+						tv.tv_sec = ts[2].tv_sec;
+						tv.tv_usec = ts[2].tv_nsec / 1000;
+					}
+
+				}
+
+				/* check for (unlikely) dropped frames on this specific socket */
+				if (dropcnt[i] != last_dropcnt[i]) {
+
+					__u32 frames = dropcnt[i] - last_dropcnt[i];
+
+					if (silent != SILENT_ON)
+						printf("DROPCOUNT: dropped %d CAN frame%s on '%s' socket (total drops %d)\n",
+						       frames, (frames > 1)?"s":"", cmdlinename[i], dropcnt[i]);
+
+					if (log)
+						fprintf(logfile, "DROPCOUNT: dropped %d CAN frame%s on '%s' socket (total drops %d)\n",
+							frames, (frames > 1)?"s":"", cmdlinename[i], dropcnt[i]);
+
+					last_dropcnt[i] = dropcnt[i];
+				}
+
+				idx = idx2dindex(addr.can_ifindex, s[i]);
+
+				/* once we detected a EFF frame indent SFF frames accordingly */
+				if (frame.can_id & CAN_EFF_FLAG)
+					view |= CANLIB_VIEW_INDENT_SFF;
+
+				if (log) {
+					char buf[CL_CFSZ]; /* max length */
+
+					/* log CAN frame with absolute timestamp & device */
+					sprint_canframe(buf, &frame, 0, maxdlen);
+					fprintf(logfile, "(%010ld.%06ld) %*s %s\n",
+						tv.tv_sec, tv.tv_usec,
+						max_devname_len, devname[idx], buf);
+				}
+
+				if (logfrmt) {
+					char buf[CL_CFSZ]; /* max length */
+
+					/* print CAN frame in log file style to stdout */
+					sprint_canframe(buf, &frame, 0, maxdlen);
+					printf("(%010ld.%06ld) %*s %s\n",
+					       tv.tv_sec, tv.tv_usec,
+					       max_devname_len, devname[idx], buf);
+					goto out_fflush; /* no other output to stdout */
+				}
+
+				if (silent != SILENT_OFF){
+					if (silent == SILENT_ANI) {
+						printf("%c\b", anichar[silentani%=MAXANI]);
+						silentani++;
+					}
+					goto out_fflush; /* no other output to stdout */
+				}
+		      
+				printf(" %s", (color>2)?col_on[idx%MAXCOL]:"");
+
+				switch (timestamp) {
+
+				case 'a': /* absolute with timestamp */
+					printf("(%010ld.%06ld) ", tv.tv_sec, tv.tv_usec);
+					break;
+
+				case 'A': /* absolute with date */
+				{
+					struct tm tm;
+					char timestring[25];
+
+					tm = *localtime(&tv.tv_sec);
+					strftime(timestring, 24, "%Y-%m-%d %H:%M:%S", &tm);
+					printf("(%s.%06ld) ", timestring, tv.tv_usec);
+				}
+				break;
+
+				case 'd': /* delta */
+				case 'z': /* starting with zero */
+				{
+					struct timeval diff;
+
+					if (last_tv.tv_sec == 0)   /* first init */
+						last_tv = tv;
+					diff.tv_sec  = tv.tv_sec  - last_tv.tv_sec;
+					diff.tv_usec = tv.tv_usec - last_tv.tv_usec;
+					if (diff.tv_usec < 0)
+						diff.tv_sec--, diff.tv_usec += 1000000;
+					if (diff.tv_sec < 0)
+						diff.tv_sec = diff.tv_usec = 0;
+					printf("(%03ld.%06ld) ", diff.tv_sec, diff.tv_usec);
+				
+					if (timestamp == 'd')
+						last_tv = tv; /* update for delta calculation */
+				}
+				break;
 
+				default: /* no timestamp output */
+					break;
+				}
 
-		idx = idx2dindex(addr.can_ifindex, s[i]);
+				printf(" %s", (color && (color<3))?col_on[idx%MAXCOL]:"");
+				printf("%*s", max_devname_len, devname[idx]);
 
-		if (log) {
-		    /* log CAN frame with absolute timestamp & device */
-		    fprintf(logfile, "(%ld.%06ld) ", tv.tv_sec, tv.tv_usec);
-		    fprintf(logfile, "%*s ", max_devname_len, devname[idx]);
-		    /* without seperator as logfile use-case is parsing */
-		    fprint_canframe(logfile, &frame, "\n", 0);
-		}
+				if (extra_msg_info) {
 
-		if (logfrmt) {
-		    /* print CAN frame in log file style to stdout */
-		    printf("(%ld.%06ld) ", tv.tv_sec, tv.tv_usec);
-		    printf("%*s ", max_devname_len, devname[idx]);
-		    fprint_canframe(stdout, &frame, "\n", 0);
-		    goto out_fflush; /* no other output to stdout */
-		}
+					if (msg.msg_flags & MSG_DONTROUTE)
+						printf ("  TX %s", extra_m_info[frame.flags & 3]);
+					else
+						printf ("  RX %s", extra_m_info[frame.flags & 3]);
+				}
 
-		if (silent){
-		    if (silent == 1) {
-			printf("%c\b", anichar[silentani%=MAXANI]);
-			silentani++;
-		    }
-		    goto out_fflush; /* no other output to stdout */
-		}
-		      
-		printf(" %s", (color>2)?col_on[idx]:"");
-
-		switch (timestamp) {
-
-		case 'a': /* absolute with timestamp */
-		    printf("(%ld.%06ld) ", tv.tv_sec, tv.tv_usec);
-		    break;
-
-		case 'A': /* absolute with date */
-		    {
-			struct tm tm;
-			char timestring[25];
-
-			tm = *localtime(&tv.tv_sec);
-			strftime(timestring, 24, "%Y-%m-%d %H:%M:%S", &tm);
-			printf("(%s.%06ld) ", timestring, tv.tv_usec);
-		    }
-		    break;
-
-		case 'd': /* delta */
-		case 'z': /* starting with zero */
-		    {
-			struct timeval diff;
-
-			if (last_tv.tv_sec == 0)   /* first init */
-			    last_tv = tv;
-			diff.tv_sec  = tv.tv_sec  - last_tv.tv_sec;
-			diff.tv_usec = tv.tv_usec - last_tv.tv_usec;
-			if (diff.tv_usec < 0)
-			    diff.tv_sec--, diff.tv_usec += 1000000;
-			if (diff.tv_sec < 0)
-			    diff.tv_sec = diff.tv_usec = 0;
-			printf("(%ld.%06ld) ", diff.tv_sec, diff.tv_usec);
-				
-			if (timestamp == 'd')
-			    last_tv = tv; /* update for delta calculation */
-		    }
-		    break;
-
-		default: /* no timestamp output */
-		    break;
-		}
-
-		printf(" %s", (color && (color<3))?col_on[idx]:"");
-		printf("%*s", max_devname_len, devname[idx]);
-		printf("%s  ", (color==1)?col_off:"");
+				printf("%s  ", (color==1)?col_off:"");
 
-		fprint_long_canframe(stdout, &frame, NULL, ascii);
+				fprint_long_canframe(stdout, &frame, NULL, view, maxdlen);
 
-		printf("%s", (color>1)?col_off:"");
-		printf("\n");
-	    }
+				printf("%s", (color>1)?col_off:"");
+				printf("\n");
+			}
 
-out_fflush:
-	    fflush(stdout);
+		out_fflush:
+			fflush(stdout);
+		}
 	}
-    }
 
-    for (i=0; i<currmax; i++)
-	close(s[i]);
+	for (i=0; i<currmax; i++)
+		close(s[i]);
 
-    if (bridge)
-      close(bridge);
+	if (bridge)
+		close(bridge);
 
-    if (log)
-	fclose(logfile);
+	if (log)
+		fclose(logfile);
 
-    return 0;
+	return 0;
 }