-/*
- * $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
* 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 <ctype.h>
#include <libgen.h>
#include <time.h>
+#include <errno.h>
#include <sys/time.h>
#include <sys/types.h>
#include "lib.h"
#define MAXSOCK 16 /* max. number of CAN interfaces given on the cmdline */
-#define MAXFILTER 30 /* max. number of possible filters for each socket */
#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
#define GREEN ATTBOLD FGGREEN
const char col_on [MAXCOL][19] = {BLUE, RED, GREEN, BOLD, MAGENTA, CYAN};
const char col_off [] = ATTRESET;
+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 4
const char anichar[MAXANI] = {'|', '/', '-', '\\'};
+const char extra_m_info[4][4] = {"- -", "B -", "- E", "B E"};
extern int optind, opterr, optopt;
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 <level> (silent mode - 1: animation 2: completely silent)\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, " -l (log CAN-frames into file)\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, "\nUp to %d comma separated filters can be specified for each given CAN interface:\n", MAXFILTER);
+ 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, "\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, "CAN IDs, masks and data content are given and expected in hexadecimal values.\n");
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 vcan2,92345678:9FFFFFFF (match only for extended CAN ID 12345678)\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");
}
break;
if (i == MAXIFNAMES) {
- printf("Interface index cache only supports %d interfaces.\n",
+ fprintf(stderr, "Interface index cache only supports %d interfaces.\n",
MAXIFNAMES);
exit(1);
}
fd_set rdfs;
int s[MAXSOCK];
int bridge = 0;
+ useconds_t bridge_delay = 0;
unsigned char timestamp = 0;
- unsigned char silent = 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;
char *ptr, *nptr;
struct sockaddr_can addr;
- struct can_filter rfilter[MAXFILTER];
+ 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 can_frame frame;
- int nbytes, i;
+ 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);
last_tv.tv_sec = 0;
last_tv.tv_usec = 0;
- while ((opt = getopt(argc, argv, "t:cias:b:B:lLh?")) != -1) {
+ while ((opt = getopt(argc, argv, "t:ciaSs:b:B:u:ldxLn:r:heT:?")) != -1) {
switch (opt) {
case 't':
timestamp = optarg[0];
if ((timestamp != 'a') && (timestamp != 'A') &&
(timestamp != 'd') && (timestamp != 'z')) {
- printf("%s: unknown timestamp mode '%c' - ignored\n",
+ fprintf(stderr, "%s: unknown timestamp mode '%c' - ignored\n",
basename(argv[0]), optarg[0]);
timestamp = 0;
}
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) {
- printf("Name of CAN device '%s' is too long!\n\n", optarg);
+ fprintf(stderr, "Name of CAN device '%s' is too long!\n\n", optarg);
return 1;
} else {
bridge = socket(PF_CAN, SOCK_RAW, CAN_RAW);
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') {
- int loopback = 0;
+ const int loopback = 0;
setsockopt(bridge, SOL_CAN_RAW, CAN_RAW_LOOPBACK,
&loopback, sizeof(loopback));
}
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);
exit(0);
}
+ if (logfrmt && view) {
+ fprintf(stderr, "Log file format selected: Please disable ASCII/BINARY/SWAP options!\n");
+ exit(0);
+ }
+
+ 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 */
+ }
+
currmax = argc - optind; /* find real number of CAN devices */
if (currmax > MAXSOCK) {
- printf("More than %d CAN devices given on commandline!\n", MAXSOCK);
+ fprintf(stderr, "More than %d CAN devices given on commandline!\n", MAXSOCK);
return 1;
}
return 1;
}
+ cmdlinename[i] = ptr; /* save pointer to cmdline name of this socket */
+
if (nptr)
nbytes = nptr - ptr; /* interface name is up the first ',' */
else
nbytes = strlen(ptr); /* no ',' found => no filter definitions */
if (nbytes >= IFNAMSIZ) {
- printf("name of CAN device '%s' is too long!\n", ptr);
+ fprintf(stderr, "name of CAN device '%s' is too long!\n", ptr);
return 1;
}
/* 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;
ptr = nptr+1; /* hop behind the ',' */
nptr = strchr(ptr, ','); /* update exit condition */
- if (sscanf(ptr, "%lx:%lx",
- (long unsigned int *)
+ if (sscanf(ptr, "%x:%x",
&rfilter[numfilter].can_id,
- (long unsigned int *)
&rfilter[numfilter].can_mask) == 2) {
+ rfilter[numfilter].can_mask &= ~CAN_ERR_FLAG;
numfilter++;
- } else if (sscanf(ptr, "%lx~%lx",
- (long unsigned int *)
+ } else if (sscanf(ptr, "%x~%x",
&rfilter[numfilter].can_id,
- (long unsigned int *)
&rfilter[numfilter].can_mask) == 2) {
- rfilter[numfilter].can_id |= CAN_INV_FILTER;
+ rfilter[numfilter].can_id |= CAN_INV_FILTER;
+ rfilter[numfilter].can_mask &= ~CAN_ERR_FLAG;
numfilter++;
- } else if (sscanf(ptr, "#%lx",
- (long unsigned int *)&err_mask) != 1) {
- printf("Error in filter option parsing: '%s'\n", ptr);
- exit(1);
- }
-
- if (numfilter > MAXFILTER) {
- printf("Too many filters specified for '%s'.\n",
- ifr.ifr_name);
- exit(1);
+ } else if (sscanf(ptr, "#%x", &err_mask) != 1) {
+ fprintf(stderr, "Error in filter option parsing: '%s'\n", ptr);
+ return 1;
}
}
if (numfilter)
setsockopt(s[i], SOL_CAN_RAW, CAN_RAW_FILTER,
- &rfilter, numfilter * sizeof(struct can_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");
+ }
+ }
+
+ if (timestamp || log || logfrmt) {
+
+ const int timestamp_on = 1;
+
+ if (setsockopt(s[i], SOL_SOCKET, SO_TIMESTAMP,
+ ×tamp_on, sizeof(timestamp_on)) < 0) {
+ perror("setsockopt SO_TIMESTAMP");
+ return 1;
+ }
+ }
+
+ if (dropmonitor) {
+
+ const int dropmonitor_on = 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 (bind(s[i], (struct sockaddr *)&addr, sizeof(addr)) < 0) {
perror("bind");
return 1;
now.tm_min,
now.tm_sec);
- printf("\nEnabling Logfile '%s'\n\n", fname);
+ if (silent != SILENT_ON)
+ printf("\nWarning: console output active while logging!");
+
+ fprintf(stderr, "\nEnabling Logfile '%s'\n\n", fname);
logfile = fopen(fname, "w");
if (!logfile) {
}
}
+ /* 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;
+
while (running) {
FD_ZERO(&rdfs);
for (i=0; i<currmax; i++)
FD_SET(s[i], &rdfs);
- if ((ret = select(s[currmax-1]+1, &rdfs, NULL, NULL, NULL)) < 0) {
+ if (timeout_current)
+ *timeout_current = timeout_config;
+
+ if ((ret = select(s[currmax-1]+1, &rdfs, NULL, NULL, timeout_current)) <= 0) {
//perror("select");
running = 0;
continue;
if (FD_ISSET(s[i], &rdfs)) {
- socklen_t len = sizeof(addr);
int idx;
- nbytes = recvfrom(s[i], &frame, sizeof(struct can_frame), 0,
- (struct sockaddr*)&addr, &len);
+ /* 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 (nbytes < sizeof(struct can_frame)) {
+ 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) {
- nbytes = write(bridge, &frame, sizeof(struct can_frame));
+ if (bridge_delay)
+ usleep(bridge_delay);
+
+ nbytes = write(bridge, &frame, nbytes);
if (nbytes < 0) {
perror("bridge write");
return 1;
- } else if (nbytes < sizeof(struct can_frame)) {
+ } 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);
+ }
+ /* check for (unlikely) dropped frames on this specific socket */
+ if (dropcnt[i] != last_dropcnt[i]) {
+
+ __u32 frames;
+
+ if (dropcnt[i] > last_dropcnt[i])
+ frames = dropcnt[i] - last_dropcnt[i];
+ else
+ frames = 4294967295U - last_dropcnt[i] + dropcnt[i]; /* 4294967295U == UINT32_MAX */
+
+ 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) {
/* log CAN frame with absolute timestamp & device */
- fprintf(logfile, "(%ld.%06ld) ", tv.tv_sec, tv.tv_usec);
+ fprintf(logfile, "(%010ld.%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);
+ fprint_canframe(logfile, &frame, "\n", 0, maxdlen);
}
if (logfrmt) {
/* print CAN frame in log file style to stdout */
- printf("(%ld.%06ld) ", tv.tv_sec, tv.tv_usec);
+ printf("(%010ld.%06ld) ", tv.tv_sec, tv.tv_usec);
printf("%*s ", max_devname_len, devname[idx]);
- fprint_canframe(stdout, &frame, "\n", 0);
+ fprint_canframe(stdout, &frame, "\n", 0, maxdlen);
goto out_fflush; /* no other output to stdout */
}
- if (silent){
- if (silent == 1) {
+ if (silent != SILENT_OFF){
+ if (silent == SILENT_ANI) {
printf("%c\b", anichar[silentani%=MAXANI]);
silentani++;
}
switch (timestamp) {
case 'a': /* absolute with timestamp */
- printf("(%ld.%06ld) ", tv.tv_sec, tv.tv_usec);
+ printf("(%010ld.%06ld) ", tv.tv_sec, tv.tv_usec);
break;
case 'A': /* absolute with date */
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);
+ printf("(%03ld.%06ld) ", diff.tv_sec, diff.tv_usec);
if (timestamp == 'd')
last_tv = tv; /* update for delta calculation */
printf(" %s", (color && (color<3))?col_on[idx%MAXCOL]:"");
printf("%*s", max_devname_len, devname[idx]);
+
+ if (extra_msg_info) {
+
+ 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]);
+ }
+
printf("%s ", (color==1)?col_off:"");
- fprint_long_canframe(stdout, &frame, NULL, view);
+ fprint_long_canframe(stdout, &frame, NULL, view, maxdlen);
printf("%s", (color>1)?col_off:"");
printf("\n");
projects / sojka / can-utils.git / blobdiff