-/*
- * $Id: candump.c,v 2.0 2006/04/13 10:37:20 ethuerm Exp $
- */
-
/*
* candump.c
*
- * Copyright (c) 2002-2005 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
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions, the following disclaimer and
- * the referenced file 'COPYING'.
+ * notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Alternatively, provided that this notice is retained in full, this
* software may be distributed under the terms of the GNU General
- * Public License ("GPL") version 2 as distributed in the 'COPYING'
- * file from the main directory of the linux kernel source.
+ * Public License ("GPL") version 2, in which case the provisions of the
+ * GPL apply INSTEAD OF those given above.
*
* The provided data structures and external interfaces from this code
* are not restricted to be used by modules with a GPL compatible license.
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
- * Send feedback to <llcf@volkswagen.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 <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/uio.h>
+#include <net/if.h>
+
+#include <linux/can.h>
+#include <linux/can/raw.h>
-#include "af_can.h"
-#include "raw.h"
#include "terminal.h"
+#include "lib.h"
-#define USE_RECVFROM /* use read() or recvfrom() syscall */
+#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 MAXDEV 6 /* change sscanf()'s manually if changed here */
-#define ANYDEV "any"
-#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 MAGENTA ATTBOLD FGMAGENTA
#define CYAN ATTBOLD FGCYAN
-static const char col_on [MAXDEV][19] = {BOLD, MAGENTA, GREEN, BLUE, CYAN, RED};
-static const char col_off [] = ATTRESET;
+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 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;
-static int running = 1;
+static volatile int running = 1;
void print_usage(char *prg)
{
- fprintf(stderr, "Usage: %s [can-interfaces]\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, " -t <type> (timestamp: Absolute/Delta/Zero)\n");
- fprintf(stderr, " -c (color mode)\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, " -a (create ASC compatible output)\n");
- fprintf(stderr, " -1 (increment interface numbering in ASC mode)\n");
- fprintf(stderr, " -A (enable ASCII output)\n");
- fprintf(stderr, "\n");
- fprintf(stderr, "When using more than one CAN interface the options\n");
- fprintf(stderr, "m/v/i 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, " -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, "\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;
+
+ for (i=0; i < MAXIFNAMES; i++) {
+ if (dindex[i] == ifidx)
+ return i;
+ }
+
+ /* create new interface index cache entry */
+
+ /* 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 < MAXIFNAMES; i++)
+ if (!dindex[i]) /* free entry */
+ break;
+
+ if (i == MAXIFNAMES) {
+ fprintf(stderr, "Interface index cache only supports %d interfaces.\n",
+ MAXIFNAMES);
+ exit(1);
+ }
+
+ dindex[i] = ifidx;
+
+ 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);
+
+ strcpy(devname[i], ifr.ifr_name);
+
+#ifdef DEBUG
+ printf("new index %d (%s)\n", i, devname[i]);
+#endif
+
+ 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};
- char devname[MAXDEV][IFNAMSIZ];
- unsigned char timestamp = 0;
- unsigned char silent = 0;
- unsigned char silentani = 0;
- unsigned char color = 0;
- unsigned char ascii = 0;
- unsigned char asc = 0;
- unsigned char asc_inc_channel = 0;
- int max_devname_len = 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;
-
- time_t currtime;
- struct timeval tv, last_tv;
-
- signal(SIGTERM, sigterm);
- signal(SIGHUP, sigterm);
- signal(SIGINT, sigterm);
-
- last_tv.tv_sec = 0; /* init */
-
- while ((opt = getopt(argc, argv, "m:v:i:b:s:ca1At:")) != -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 '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;
+ 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;
+ 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:?")) != -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 '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;
+ }
- if (bind(bridge, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
- perror("bridge bind");
- return 1;
- }
- }
- break;
+ /* 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 's':
- silent = atoi(optarg);
- break;
-
- case 'c':
- color = 1;
- break;
-
- case 'a':
- asc = 1;
- break;
-
- case '1':
- asc_inc_channel = 1;
- break;
-
- case 'A':
- ascii = 1;
- 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 '?':
- break;
-
- default:
- fprintf(stderr, "Unknown option %c\n", opt);
- 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 (optind == argc) {
- print_usage(basename(argv[0]));
- exit(0);
- }
+ 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;
- }
+ if (logfrmt && view) {
+ fprintf(stderr, "Log file format selected: Please disable ASCII/BINARY/SWAP options!\n");
+ exit(0);
+ }
- currmax = argc - optind; /* find real number of CAN devices */
+ 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) {
+ 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.\n",
- i, argv[optind+i], mask[i], value[i], inv_filter[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 */
- if (!(asc)) /* this output is not asc compatible! */
- 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 */
- j = strlen(argv[optind+i]);
+ addr.can_family = AF_CAN;
- if (!(j < IFNAMSIZ)) {
- printf("name of CAN device '%s' is too long!\n", argv[optind+i]);
- return 1;
- }
+ memset(&ifr.ifr_name, 0, sizeof(ifr.ifr_name));
+ strncpy(ifr.ifr_name, ptr, nbytes);
- strcpy(devname[i], argv[optind+i]);
+#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 */
- addr.can_family = AF_CAN;
+ if (nptr) {
- if (strcmp(ANYDEV, argv[optind+i])) {
- strcpy(ifr.ifr_name, argv[optind+i]);
- if (ioctl(s[i], SIOCGIFINDEX, &ifr) < 0)
- perror("SIOCGIFINDEX");
- addr.can_ifindex = ifr.ifr_ifindex;
- }
- else
- addr.can_ifindex = 0; /* any can interface */
+ /* found a ',' after the interface name => check for filters */
- if (bind(s[i], (struct sockaddr *)&addr, sizeof(addr)) < 0) {
- perror("bind");
- return 1;
- }
- }
+ /* 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;
+
+ 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 (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 (asc) {
- char datestring[40];
+ if (numfilter)
+ setsockopt(s[i], SOL_CAN_RAW, CAN_RAW_FILTER,
+ rfilter, numfilter * sizeof(struct can_filter));
- /* print banner for ASC mode */
+ free(rfilter);
- if (timestamp != 'd') /* delta time is allowed, else ... */
- timestamp = 'z'; /* ASC-files always start with zero time */
+ } /* if (nptr) */
- if (time(&currtime) == (time_t)-1) {
- perror("time");
- return 1;
+ /* 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;
+ }
}
- strncpy(datestring, ctime(&currtime), 39); /* copy to private buffer */
- datestring[strlen(datestring)-1] = 0; /* chop off trailing newline */
- printf("date %s%s", datestring, ANL); /* print with own new line representation */
- printf("base hex timestamps %s%s", (timestamp == 'd')?"relative":"absolute", ANL);
- printf("no internal events logged%s", ANL);
- fflush(stdout);
- }
+ if (log) {
+ time_t currtime;
+ struct tm now;
+ char fname[sizeof("candump-2006-11-20_202026.log")+1];
+
+ if (time(&currtime) == (time_t)-1) {
+ perror("time");
+ return 1;
+ }
- while (running) {
+ localtime_r(&currtime, &now);
- FD_ZERO(&rdfs);
+ 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);
- for (i=0; i<currmax; i++)
- FD_SET(s[i], &rdfs);
+ if (silent != SILENT_ON)
+ printf("\nWarning: console output active while logging!");
+
+ 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++) {
+ /* 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) {
-#ifdef USE_RECVFROM
- socklen_t len = sizeof(addr);
- if ((nbytes = recvfrom(s[i], &frame, sizeof(struct can_frame), 0, (struct sockaddr*)&addr, &len)) < 0) {
-#else
- if ((nbytes = read(s[i], &frame, sizeof(struct can_frame))) < 0) {
-#endif
- perror("read");
- return 1;
- } else if (nbytes < sizeof(struct can_frame)) {
- fprintf(stderr, "read: incomplete CAN frame\n");
- return 1;
- } else {
- 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;
- }
- }
+ FD_ZERO(&rdfs);
+ for (i=0; i<currmax; i++)
+ FD_SET(s[i], &rdfs);
+
+ 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;
+ }
+
+ 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 (silent){
- if (silent == 1)
- printf("%c\b", anichar[silentani%=MAXANI]), silentani++;
- }
- else {
+ 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, "(%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, maxdlen);
+ }
+
+ if (logfrmt) {
+ /* print CAN frame in log file style to stdout */
+ printf("(%010ld.%06ld) ", tv.tv_sec, tv.tv_usec);
+ printf("%*s ", max_devname_len, devname[idx]);
+ fprint_canframe(stdout, &frame, "\n", 0, maxdlen);
+ 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 */
+ }
- switch (timestamp) {
-
- case 'a': /* absolute with timestamp */
- if (ioctl(s[i], SIOCGSTAMP, &tv) < 0)
- perror("SIOCGSTAMP");
- if (asc)
- printf("%4ld.%04ld ", tv.tv_sec, tv.tv_usec/100);
- else
- printf("(%ld.%06ld) ", tv.tv_sec, tv.tv_usec);
- break;
-
- case 'A': /* absolute with date */
- {
- struct tm tm;
- char timestring[25];
- if (ioctl(s[i], SIOCGSTAMP, &tv) < 0)
- perror("SIOCGSTAMP");
- tm = *localtime(&tv.tv_sec);
- strftime(timestring, 24, "%Y-%m-%d %H:%M:%S", &tm);
- if (asc)
- printf("%s.%04ld ", timestring, tv.tv_usec/100);
- else
- printf("(%s.%06ld) ", timestring, tv.tv_usec);
- }
- break;
-
- case 'd': /* delta */
- case 'z': /* starting with zero */
- {
- struct timeval diff;
-
- if (ioctl(s[i], SIOCGSTAMP, &tv) < 0)
- perror("SIOCGSTAMP");
- 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;
- if (asc)
- printf("%4ld.%04ld ", diff.tv_sec, diff.tv_usec/100);
- else
- printf("(%ld.%06ld) ", diff.tv_sec, diff.tv_usec);
-
- if (timestamp == 'd')
- last_tv = tv; /* update for delta calculation */
- }
- break;
+ printf(" %s", (color>2)?col_on[idx%MAXCOL]:"");
- default: /* no timestamp output */
- break;
- }
+ switch (timestamp) {
+
+ case 'a': /* absolute with timestamp */
+ printf("(%010ld.%06ld) ", tv.tv_sec, tv.tv_usec);
+ break;
- if (asc) {
- char id[10];
+ 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;
- printf("%-2d ", i + asc_inc_channel); /* channel number - left aligned */
+ default: /* no timestamp output */
+ break;
+ }
- sprintf(id, "%X%c", frame.can_id & CAN_EFF_MASK,
- (frame.can_id & CAN_EFF_FLAG)?'x':' ');
- printf("%-15s Rx ", id);
+ printf(" %s", (color && (color<3))?col_on[idx%MAXCOL]:"");
+ printf("%*s", max_devname_len, devname[idx]);
- if (frame.can_id & CAN_RTR_FLAG)
- printf("r"); /* RTR frame: nothing else to print */
- else {
- printf("d %d ", frame.can_dlc); /* data frame */
+ if (extra_msg_info) {
- for (j = 0; j < frame.can_dlc; j++) {
- printf("%02X ", frame.data[j]);
+ 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", ANL);
- }
- else {
- printf(" %s",(color)?col_on[i]:"");
-#ifdef USE_RECVFROM
- ifr.ifr_ifindex = addr.can_ifindex;
- if (ioctl(s[i], SIOCGIFNAME, &ifr) < 0)
- perror("SIOCGIFNAME");
-
- if (max_devname_len < strlen(ifr.ifr_name))
- max_devname_len = strlen(ifr.ifr_name);
-
- printf("%*s", max_devname_len, ifr.ifr_name);
-#else
- printf("%*s", max_devname_len, devname[i]); /* device name */
-#endif
- printf("%s ",(color)?col_off:"");
- if (frame.can_id & CAN_EFF_FLAG)
- printf("%8X ", frame.can_id & CAN_EFF_MASK);
- else
- printf("%3X ", frame.can_id & CAN_SFF_MASK);
-
- printf("[%d] ", frame.can_dlc);
-
- for (j = 0; j < frame.can_dlc; j++) {
- printf("%02X ", frame.data[j]);
- }
- if (ascii) {
- printf("%*s", 3*(8-frame.can_dlc)+3, "'");
- for (j = 0; j < frame.can_dlc; j++)
- if ((frame.data[j] > 0x1F) && (frame.data[j] < 0x7F))
- putchar(frame.data[j]);
- else
- putchar('.');
- printf("' ");
- }
- if (frame.can_id & CAN_RTR_FLAG)
- printf("remote request");
- printf("\n");
+
+ printf("%s ", (color==1)?col_off:"");
+
+ fprint_long_canframe(stdout, &frame, NULL, view, maxdlen);
+
+ printf("%s", (color>1)?col_off:"");
+ printf("\n");
}
- }
- 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);
- return 0;
+ return 0;
}
projects / sojka / can-utils.git / blobdiff