From e7a59a9ea4a848655d37930f7fa3cf1b8c86bf2e Mon Sep 17 00:00:00 2001
From: Urs Thuermann <urs.thuermann@volkswagen.de>
Date: Mon, 24 Apr 2006 14:14:09 +0000
Subject: [PATCH] Initial import of llcf-2.0-pre2

---
 Makefile      |  65 +++++
 can-sniffer.c | 697 ++++++++++++++++++++++++++++++++++++++++++++++++++
 candump.c     | 509 ++++++++++++++++++++++++++++++++++++
 terminal.h    |  99 +++++++
 4 files changed, 1370 insertions(+)
 create mode 100644 Makefile
 create mode 100644 can-sniffer.c
 create mode 100644 candump.c
 create mode 100644 terminal.h

diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..17d4e13
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,65 @@
+#
+#  $Id: Makefile,v 2.0 2006/04/13 10:37:20 ethuerm Exp $
+#
+#  Copyright (c) 2002-2005 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'.
+#  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.
+#  3. Neither the name of Volkswagen nor the names of its contributors
+#     may be used to endorse or promote products derived from this software
+#     without specific prior written permission.
+#
+#  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.
+#
+#  The provided data structures and external interfaces from this code
+#  are not restricted to be used by modules with a GPL compatible license.
+#
+#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+#  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+#  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+#  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+#  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+#  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+#  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+#  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+#  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+#  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+#  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+#  DAMAGE.
+#
+#  Send feedback to <llcf@volkswagen.de>
+
+CFLAGS    = -O2 -Wall -Wno-parentheses -I../kernel/2.4/can -fno-strict-aliasing
+
+PROGRAMS_GPL = 	candump		\
+		can-sniffer
+
+PROGRAMS_VW = 	tpdump		\
+		tp20-sniffer	\
+		mcnet-vit-emu	\
+		mcnet-sniffer	\
+		pq35speed
+
+default: all-gpl
+
+all: all-gpl all-vw
+
+all-gpl: $(PROGRAMS_GPL)
+all-vw:  $(PROGRAMS_VW)
+
+clean:
+	rm -f $(PROGRAMS_GPL) $(PROGRAMS_VW)
+
+distclean:
+	rm -f $(PROGRAMS_GPL) $(PROGRAMS_VW) *~
diff --git a/can-sniffer.c b/can-sniffer.c
new file mode 100644
index 0000000..e4b4243
--- /dev/null
+++ b/can-sniffer.c
@@ -0,0 +1,697 @@
+/*
+ *  $Id: can-sniffer.c,v 2.0 2006/04/13 10:37:20 ethuerm Exp $
+ */
+
+/*
+ * can-sniffer.c
+ *
+ * Copyright (c) 2002-2005 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'.
+ * 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.
+ * 3. Neither the name of Volkswagen nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * 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.
+ *
+ * The provided data structures and external interfaces from this code
+ * are not restricted to be used by modules with a GPL compatible license.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ * Send feedback to <llcf@volkswagen.de>
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <ctype.h>
+#include <libgen.h>
+#include <time.h>
+
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <sys/uio.h>
+
+#include "af_can.h"
+#include "bcm.h"
+#include "terminal.h"
+
+#define U64_DATA(p) (*(unsigned long long*)(p)->data)
+
+#define SETFNAME "sniffset."
+
+/* flags */
+
+#define ENABLE  1 /* by filter or user */
+#define DISPLAY 2 /* is on the screen */
+#define UPDATE  4 /* needs to be printed on the screen */
+#define CLRSCR  8 /* clear screen in next loop */
+
+/* flags testing & setting */
+
+#define is_set(id, flag) (sniftab[id].flags & flag)
+#define is_clr(id, flag) (!(sniftab[id].flags & flag))
+
+#define do_set(id, flag) (sniftab[id].flags |= flag)
+#define do_clr(id, flag) (sniftab[id].flags &= ~flag)
+
+/* time defaults */
+
+#define TIMEOUT 50 /* in 100ms */
+#define HOLD    10 /* in 100ms */
+#define LOOP     2 /* in 100ms */
+
+#define MAXANI 8
+const char anichar[MAXANI] = {'|', '/', '-', '\\', '|', '/', '-', '\\'};
+
+#define ATTCOLOR ATTBOLD FGRED
+
+#define STARTLINESTR "X  time    ID  data ... "
+
+struct snif {
+    int flags;
+    long hold;
+    long timeout;
+    struct timeval laststamp;
+    struct timeval currstamp;
+    struct can_frame last;
+    struct can_frame current;
+    struct can_frame marker;
+    struct can_frame notch;
+} sniftab[2048];
+
+
+extern int optind, opterr, optopt;
+
+static int running = 1;
+static int clearscreen = 1;
+static int notch = 0;
+static long timeout = TIMEOUT;
+static long hold = HOLD;
+static long loop = LOOP;
+static unsigned char binary = 0;
+static unsigned char color  = 0;
+
+void rx_setup (int fd, int id);
+void rx_delete (int fd, int id);
+void print_snifline(int id);
+int handle_keyb(int fd);
+int handle_bcm(int fd, long currcms);
+int handle_timeo(int fd, long currcms);
+void writesettings(char* name);
+void readsettings(char* name, int sockfd);
+
+void print_usage(char *prg)
+{
+    const char manual [] = {
+	"commands that can be entered at runtime:\n"
+	"\n"
+	"q<ENTER>       - quit\n"
+	"b<ENTER>       - toggle binary / HEX-ASCII output\n"
+	"c<ENTER>       - toggle color mode\n"
+	"#<ENTER>       - notch currently marked/changed bits (can be used repeatedly)\n"
+	"*<ENTER>       - clear notched marked\n"
+	"rMYNAME<ENTER> - read settings file (filter/notch)\n"
+	"wMYNAME<ENTER> - write settings file (filter/notch)\n"
+	"+FILTER<ENTER> - add CAN-IDs to sniff\n"
+	"-FILTER<ENTER> - remove CAN-IDs to sniff\n"
+	"\n"
+	"FILTER can be a single CAN-ID or a CAN-ID/Bitmask:\n"
+	"+1F5<ENTER>    - add CAN-ID 0x1F5\n"
+	"-42E<ENTER>    - remove CAN-ID 0x42E\n"
+	"-42E7FF<ENTER> - remove CAN-ID 0x42E (using Bitmask)\n"
+	"-500700<ENTER> - remove CAN-IDs 0x500 - 0x5FF\n"
+	"+400600<ENTER> - add CAN-IDs 0x400 - 0x5FF\n"
+	"+000000<ENTER> - add all CAN-IDs\n"
+	"-000000<ENTER> - remove all CAN-IDs\n"
+	"\n"
+	"if (id & filter) == (sniff-id & filter) the action (+/-) is performed,\n"
+	"which is quite easy when the filter is 000\n"
+	"\n"
+    };
+
+    fprintf(stderr, "\nUsage: %s [can-interface]\n", prg);
+    fprintf(stderr, "Options: -m <mask>  (initial FILTER default 0x00000000)\n");
+    fprintf(stderr, "         -v <value> (initial FILTER default 0x00000000)\n");
+    fprintf(stderr, "         -q         (quiet - all IDs deactivated)\n");
+    fprintf(stderr, "         -r <name>  (read %sname from file)\n", SETFNAME);
+    fprintf(stderr, "         -b         (start with binary mode)\n");
+    fprintf(stderr, "         -c         (color changes)\n");
+    fprintf(stderr, "         -t <time>  (timeout for ID display [x100ms] default: %d)\n", TIMEOUT);
+    fprintf(stderr, "         -h <time>  (hold marker on changes [x100ms] default: %d)\n", HOLD);
+    fprintf(stderr, "         -l <time>  (loop time (display) [x100ms] default: %d)\n", LOOP);
+    fprintf(stderr, "\n");
+    fprintf(stderr, "%s", manual);
+}
+
+void sigterm(int signo)
+{
+    running = 0;
+}
+
+int main(int argc, char **argv)
+{
+    fd_set rdfs;
+    int s;
+    canid_t mask = 0;
+    canid_t value = 0;
+    long currcms = 0;
+    long lastcms = 0;
+    unsigned char quiet = 0;
+
+    int opt, ret;
+    struct timeval timeo, start_tv, tv;
+    struct sockaddr_can addr;
+    struct ifreq ifr;
+    int i;
+
+
+    signal(SIGTERM, sigterm);
+    signal(SIGHUP, sigterm);
+    signal(SIGINT, sigterm);
+
+    for (i=0; i < 2048 ;i++) /* default: check all CAN-IDs */
+	do_set(i, ENABLE);
+
+    while ((opt = getopt(argc, argv, "m:v:r:t:h:l:qbc")) != -1) {
+	switch (opt) {
+	case 'm':
+	    sscanf(optarg, "%x", &mask);
+	    break;
+
+	case 'v':
+	    sscanf(optarg, "%x", &value);
+	    break;
+
+	case 'r':
+	    readsettings(optarg, 0); /* no BCM-setting here */
+	    break;
+
+	case 't':
+	    sscanf(optarg, "%ld", &timeout);
+	    break;
+
+	case 'h':
+	    sscanf(optarg, "%ld", &hold);
+	    break;
+
+	case 'l':
+	    sscanf(optarg, "%ld", &loop);
+	    break;
+
+	case 'q':
+	    quiet = 1;
+	    break;
+
+	case 'b':
+	    binary = 1;
+	    break;
+
+	case 'c':
+	    color = 1;
+	    break;
+
+	case '?':
+	    break;
+
+	default:
+	    fprintf(stderr, "Unknown option %c\n", opt);
+	    break;
+	}
+    }
+
+    if (optind == argc) {
+	print_usage(basename(argv[0]));
+	exit(0);
+    }
+	
+    if (mask || value) {
+	for (i=0; i < 2048 ;i++) {
+	    if ((i & mask) ==  (value & mask))
+		do_set(i, ENABLE);
+	    else
+		do_clr(i, ENABLE);
+	}
+    }
+
+    if (quiet)
+	for (i=0; i < 2048 ;i++)
+	    do_clr(i, ENABLE);
+
+    if (strlen(argv[optind]) >= IFNAMSIZ) {
+	printf("name of CAN device '%s' is too long!\n", argv[optind]);
+	return 1;
+    }
+
+    if ((s = socket(PF_CAN, SOCK_DGRAM, CAN_BCM)) < 0) {
+	perror("socket");
+	return 1;
+    }
+
+    addr.can_family = AF_CAN;
+    strcpy(ifr.ifr_name, argv[optind]);
+    ioctl(s, SIOCGIFINDEX, &ifr);
+    addr.can_ifindex = ifr.ifr_ifindex;
+
+    if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+	perror("bind");
+	return 1;
+    }
+
+    for (i=0; i < 2048 ;i++) /* initial BCM setup */
+	if (is_set(i, ENABLE))
+	    rx_setup(s, i);
+
+    gettimeofday(&start_tv, NULL);
+    tv.tv_sec = tv.tv_usec = 0;
+
+    printf("%s", CSR_HIDE); /* hide cursor */
+
+    while (running) {
+
+	FD_ZERO(&rdfs);
+	FD_SET(0, &rdfs);
+	FD_SET(s, &rdfs);
+
+	timeo.tv_sec  = 0;
+	timeo.tv_usec = 100000 * loop;
+
+	if ((ret = select(s+1, &rdfs, NULL, NULL, &timeo)) < 0) {
+	    //perror("select");
+	    running = 0;
+	    continue;
+	}
+
+	gettimeofday(&tv, NULL);
+	currcms = (tv.tv_sec - start_tv.tv_sec) * 10 + (tv.tv_usec / 100000);
+
+	if (FD_ISSET(0, &rdfs))
+	    running &= handle_keyb(s);
+
+	if (FD_ISSET(s, &rdfs))
+	    running &= handle_bcm(s, currcms);
+
+        if (currcms - lastcms >= loop) {
+		running &= handle_timeo(s, currcms);
+		lastcms = currcms;
+	}
+    }
+
+    printf("%s", CSR_SHOW); /* show cursor */
+
+    close(s);
+    return 0;
+}
+
+void rx_setup (int fd, int id){
+
+    struct {
+	struct bcm_msg_head msg_head;
+	struct can_frame frame;
+    } txmsg;
+
+    txmsg.msg_head.opcode  = RX_SETUP;
+    txmsg.msg_head.can_id  = id;
+    txmsg.msg_head.flags   = RX_CHECK_DLC;
+    txmsg.msg_head.ival1.tv_sec  = 0;
+    txmsg.msg_head.ival1.tv_usec = 0;
+    txmsg.msg_head.ival2.tv_sec  = 0;
+    txmsg.msg_head.ival2.tv_usec = 0;
+    txmsg.msg_head.nframes = 1;
+    U64_DATA(&txmsg.frame) = (__u64) 0xFFFFFFFFFFFFFFFFULL;
+
+    if (write(fd, &txmsg, sizeof(txmsg)) < 0)
+      perror("write");
+};
+
+void rx_delete (int fd, int id){
+
+    struct bcm_msg_head msg_head;
+
+    msg_head.opcode  = RX_DELETE;
+    msg_head.can_id  = id;
+    msg_head.nframes = 0;
+
+    if (write(fd, &msg_head, sizeof(msg_head)) < 0)
+      perror("write");
+}
+
+int handle_keyb(int fd){
+
+    char cmd [20] = {0};
+    int i;
+    unsigned int mask;
+    unsigned int value;
+
+    if (read(0, cmd, 19) > strlen("+123456\n"))
+	return 1; /* ignore */
+
+    if (strlen(cmd) > 0)
+	cmd[strlen(cmd)-1] = 0; /* chop off trailing newline */
+
+    switch (cmd[0]) {
+
+    case '+':
+    case '-':
+	sscanf(&cmd[1], "%x", &value);
+	if (strlen(&cmd[1]) > 3) {
+	    mask = value & 0xFFF;
+	    value >>= 12;
+	}
+	else
+	    mask = 0x7FF;
+
+	if (cmd[0] == '+') {
+	    for (i=0; i < 2048 ;i++) {
+		if (((i & mask) == (value & mask)) && (is_clr(i, ENABLE))) {
+		    do_set(i, ENABLE);
+		    rx_setup(fd, i);
+		}
+	    }
+	}
+	else { /* '-' */
+	    for (i=0; i < 2048 ;i++) {
+		if (((i & mask) == (value & mask)) && (is_set(i, ENABLE))) {
+		    do_clr(i, ENABLE);
+		    rx_delete(fd, i);
+		}
+	    }
+	}
+	break;
+
+    case 'w' :
+	writesettings(&cmd[1]);
+	break;
+
+    case 'r' :
+	readsettings(&cmd[1], fd);
+	break;
+
+    case 'q' :
+	running = 0;
+	break;
+
+    case 'b' :
+	if (binary)
+	    binary = 0;
+	else
+	    binary = 1;
+
+	break;
+
+    case 'c' :
+	if (color)
+	    color = 0;
+	else
+	    color = 1;
+
+	break;
+
+    case '#' :
+	notch = 1;
+	break;
+
+    case '*' :
+	for (i=0; i < 2048; i++)
+	    U64_DATA(&sniftab[i].notch) = (__u64) 0;
+	break;
+
+    default:
+	break;
+    }
+
+    clearscreen = 1;
+
+    return 1; /* ok */
+};
+
+int handle_bcm(int fd, long currcms){
+
+    int nbytes, id;
+
+    struct {
+        struct bcm_msg_head msg_head;
+        struct can_frame frame;
+    } bmsg;
+
+    if ((nbytes = read(fd, &bmsg, sizeof(bmsg))) < 0) {
+        perror("bcm read");
+        return 0; /* quit */
+    }
+
+    id = bmsg.msg_head.can_id;
+    ioctl(fd, SIOCGSTAMP, &sniftab[id].currstamp);
+
+    if (bmsg.msg_head.opcode != RX_CHANGED) {
+	printf("received strange BCM opcode %d!\n", bmsg.msg_head.opcode);
+        return 0; /* quit */
+    }
+
+    if (nbytes != sizeof(bmsg)) {
+	printf("received strange BCM data length %d!\n", nbytes);
+        return 0; /* quit */
+    }
+
+    sniftab[id].current = bmsg.frame;
+    U64_DATA(&sniftab[id].marker) |= 
+	U64_DATA(&sniftab[id].current) ^ U64_DATA(&sniftab[id].last);
+    sniftab[id].timeout = currcms + timeout;
+
+    if (is_clr(id, DISPLAY))
+	clearscreen = 1; /* new entry -> new drawing */
+
+    do_set(id, DISPLAY);
+    do_set(id, UPDATE);
+	
+    return 1; /* ok */
+};
+
+int handle_timeo(int fd, long currcms){
+
+    int i;
+    int force_redraw = 0;
+
+    if (clearscreen) {
+	char startline[80];
+	printf("%s%s", CLR_SCREEN, CSR_HOME);
+	snprintf(startline, 79, "< can-sniffer parameters: l=%ld h=%ld t=%ld >", loop, hold, timeout);
+	printf("%s%*s",STARTLINESTR, 79-strlen(STARTLINESTR), startline); 
+	force_redraw = 1;
+	clearscreen = 0;
+    }
+
+    if (notch) {
+	for (i=0; i < 2048; i++)
+	    U64_DATA(&sniftab[i].notch) |= U64_DATA(&sniftab[i].marker);
+	notch = 0;
+    }
+
+    printf("%s", CSR_HOME);
+    printf("%c\n", anichar[currcms % MAXANI]); /* funny animation */
+
+    for (i=0; i < 2048; i++) {
+
+	if is_set(i, ENABLE) {
+
+	    if is_set(i, DISPLAY) {
+
+		if (is_set(i, UPDATE) || (force_redraw)){
+		    print_snifline(i);
+		    sniftab[i].hold = currcms + hold;
+		    do_clr(i, UPDATE);
+		}
+		else
+		    if ((sniftab[i].hold) && (sniftab[i].hold < currcms)) {
+			U64_DATA(&sniftab[i].marker) = (__u64) 0;
+			print_snifline(i);
+			sniftab[i].hold = 0; /* disable update by hold */
+		    }
+		    else
+			printf("%s", CSR_DOWN); /* skip my line */
+
+		if (sniftab[i].timeout < currcms) {
+		    do_clr(i, DISPLAY);
+		    do_clr(i, UPDATE);
+		    clearscreen = 1; /* removed entry -> new drawing next time */
+		}
+	    }
+	    sniftab[i].last      = sniftab[i].current;
+	    sniftab[i].laststamp = sniftab[i].currstamp;
+	}
+    }
+
+    return 1; /* ok */
+
+};
+
+void print_snifline(int id){
+
+    long diffsec  = sniftab[id].currstamp.tv_sec  - sniftab[id].laststamp.tv_sec;
+    long diffusec = sniftab[id].currstamp.tv_usec - sniftab[id].laststamp.tv_usec;
+    int i,j;
+
+    if (diffusec < 0)
+	diffsec--, diffusec += 1000000;
+
+    if (diffsec < 0)
+	diffsec = diffusec = 0;
+
+    if (diffsec > 10)
+	diffsec = 9, diffusec = 999999;
+
+    printf("%ld.%06ld  %3x  ", diffsec, diffusec, id);
+
+    if (binary) {
+
+	for (i=0; i<sniftab[id].current.can_dlc; i++)
+	    for (j=7; j>=0; j--)
+		if ((color) && (sniftab[id].marker.data[i] & 1<<j) &&
+		    (!(sniftab[id].notch.data[i] & 1<<j)))
+		    if (sniftab[id].current.data[i] & 1<<j)
+			printf("%s1%s", ATTCOLOR, ATTRESET);
+		    else
+			printf("%s0%s", ATTCOLOR, ATTRESET);
+		else
+		    if (sniftab[id].current.data[i] & 1<<j)
+			putchar('1');
+		    else
+			putchar('0');
+    }
+    else {
+
+	for (i=0; i<sniftab[id].current.can_dlc; i++)
+	    if ((color) && (sniftab[id].marker.data[i]) && (!(sniftab[id].notch.data[i])))
+		printf("%s%02X%s ", ATTCOLOR, sniftab[id].current.data[i], ATTRESET);
+	    else
+		printf("%02X ", sniftab[id].current.data[i]);
+
+	if (sniftab[id].current.can_dlc < 8)
+	    printf("%*s", (8 - sniftab[id].current.can_dlc) * 3, "");
+
+	for (i=0; i<sniftab[id].current.can_dlc; i++)
+	    if ((sniftab[id].current.data[i] > 0x1F) && 
+		(sniftab[id].current.data[i] < 0x7F))
+		if ((color) && (sniftab[id].marker.data[i]) && (!(sniftab[id].notch.data[i])))
+		    printf("%s%c%s", ATTCOLOR, sniftab[id].current.data[i], ATTRESET);
+		else
+		    putchar(sniftab[id].current.data[i]);
+	    else
+		putchar('.');
+    }
+
+    putchar('\n');
+
+    U64_DATA(&sniftab[id].marker) = (__u64) 0;
+
+};
+
+
+void writesettings(char* name){
+
+    int fd;
+    char fname[30] = SETFNAME;
+    int i,j;
+    char buf[8]= {0};
+
+    strncat(fname, name, 29 - strlen(fname)); 
+    fd = open(fname,  O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
+    
+    if (fd > 0) {
+
+	for (i=0; i < 2048 ;i++) {
+	    sprintf(buf, "<%03X>%c.", i, (is_set(i, ENABLE))?'1':'0');
+	    write(fd, buf, 7);
+	    for (j=0; j<8 ; j++){
+		sprintf(buf, "%02X", sniftab[i].notch.data[j]);
+		write(fd, buf, 2);
+	    }
+	    write(fd, "\n", 1);
+	    /* 7 + 16 + 1 = 24 bytes per entry */ 
+	}
+	close(fd);
+    }
+    else
+	printf("unable to write setting file '%s'!\n", fname);
+};
+
+void readsettings(char* name, int sockfd){
+
+    int fd;
+    char fname[30] = SETFNAME;
+    char buf[25] = {0};
+    int i,j;
+
+    strncat(fname, name, 29 - strlen(fname)); 
+    fd = open(fname, O_RDONLY);
+    
+    if (fd > 0) {
+	if (!sockfd)
+	    printf("reading setting file '%s' ... ", fname);
+
+	for (i=0; i < 2048 ;i++) {
+	    if (read(fd, &buf, 24) == 24) {
+		if (buf[5] & 1) {
+		    if (is_clr(i, ENABLE)) {
+			do_set(i, ENABLE);
+			if (sockfd)
+			    rx_setup(sockfd, i);
+		    }
+		}
+		else
+		    if (is_set(i, ENABLE)) {
+			do_clr(i, ENABLE);
+			if (sockfd)
+			    rx_delete(sockfd, i);
+		    }
+		for (j=7; j>=0 ; j--){
+		    sniftab[i].notch.data[j] =
+			(__u8) strtoul(&buf[2*j+7], (char **)NULL, 16) & 0xFF;
+		    buf[2*j+7] = 0; /* cut off each time */
+		}
+	    }
+	    else {
+		if (!sockfd)
+		    printf("was only able to read until index %d from setting file '%s'!\n",
+			   i, fname);
+	    }
+	}
+    
+	if (!sockfd)
+	    printf("done\n");
+
+	close(fd);
+    }
+    else
+	printf("unable to read setting file '%s'!\n", fname);
+};
diff --git a/candump.c b/candump.c
new file mode 100644
index 0000000..b49fc75
--- /dev/null
+++ b/candump.c
@@ -0,0 +1,509 @@
+/*
+ *  $Id: candump.c,v 2.0 2006/04/13 10:37:20 ethuerm Exp $
+ */
+
+/*
+ * candump.c
+ *
+ * Copyright (c) 2002-2005 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'.
+ * 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.
+ * 3. Neither the name of Volkswagen nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * 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.
+ *
+ * The provided data structures and external interfaces from this code
+ * are not restricted to be used by modules with a GPL compatible license.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ * Send feedback to <llcf@volkswagen.de>
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <signal.h>
+#include <ctype.h>
+#include <libgen.h>
+#include <time.h>
+
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <sys/uio.h>
+
+#include "af_can.h"
+#include "raw.h"
+#include "terminal.h"
+
+#define USE_RECVFROM /* use read() or recvfrom() syscall */
+
+#define MAXDEV 6 /* change sscanf()'s manually if changed here */
+#define ANYDEV "any"
+#define ANL "\r\n" /* newline in ASC mode */
+
+#define BOLD    ATTBOLD
+#define RED     ATTBOLD FGRED
+#define GREEN   ATTBOLD FGGREEN
+#define YELLOW  ATTBOLD FGYELLOW
+#define BLUE    ATTBOLD FGBLUE
+#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;
+
+#define MAXANI 8
+const char anichar[MAXANI] = {'|', '/', '-', '\\', '|', '/', '-', '\\'};
+
+extern int optind, opterr, optopt;
+
+static 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);
+}
+
+void sigterm(int signo)
+{
+    running = 0;
+}
+
+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;
+		
+		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;
+	    
+	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;
+	}
+    }
+
+    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 */
+
+    if (currmax > MAXDEV) {
+	printf("More than %d CAN devices!\n", MAXDEV);
+	return 1;
+    }
+
+    for (i=0; i<currmax; i++) {
+
+#ifdef DEBUG
+	printf("open %d '%s' m%08X v%08X i%d.\n",
+	       i, argv[optind+i], mask[i], value[i], inv_filter[i]);
+#endif
+
+	if ((s[i] = socket(PF_CAN, SOCK_RAW, CAN_RAW)) < 0) {
+	    perror("socket");
+	    return 1;
+	}
+
+	if (mask[i] || value[i]) {
+
+	    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)" : "");
+
+	    rfilter.can_id   = value[i];
+	    rfilter.can_mask = mask[i];
+	    if (inv_filter[i])
+		rfilter.can_id |= CAN_INV_FILTER;
+
+	    setsockopt(s[i], SOL_CAN_RAW, CAN_RAW_FILTER, &rfilter, sizeof(rfilter));
+	}
+
+	j = strlen(argv[optind+i]);
+
+	if (!(j < IFNAMSIZ)) {
+	    printf("name of CAN device '%s' is too long!\n", argv[optind+i]);
+	    return 1;
+	}
+
+	strcpy(devname[i], argv[optind+i]);
+
+	if (j > max_devname_len)
+	    max_devname_len = j; /* for nice printing */
+
+	addr.can_family = AF_CAN;
+
+	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 */
+
+	if (bind(s[i], (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+	    perror("bind");
+	    return 1;
+	}
+    }
+
+    if (asc) {
+	char datestring[40];
+
+	/* print banner for ASC mode */
+
+	if (timestamp != 'd') /* delta time is allowed, else ... */
+	    timestamp = 'z'; /* ASC-files always start with zero time */
+
+	if (time(&currtime) == (time_t)-1) {
+	    perror("time");
+	    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);
+    }
+
+    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) {
+	    //perror("select");
+	    running = 0;
+	    continue;
+	}
+
+	for (i=0; i<currmax; i++) {
+
+	    if (FD_ISSET(s[i], &rdfs)) {
+
+#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;
+			}
+		    }
+		    
+		    if (silent){
+		      if (silent == 1)
+			printf("%c\b", anichar[silentani%=MAXANI]), silentani++;
+		    }
+		    else {
+		      
+			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;
+
+			default: /* no timestamp output */
+			    break;
+			}
+
+			if (asc) {
+			    char id[10];
+
+			    printf("%-2d ", i + asc_inc_channel); /* channel number - left aligned */
+
+			    sprintf(id, "%X%c", frame.can_id & CAN_EFF_MASK,
+				    (frame.can_id & CAN_EFF_FLAG)?'x':' ');
+			    printf("%-15s Rx   ", id);
+
+			    if (frame.can_id & CAN_RTR_FLAG)
+				printf("r"); /* RTR frame: nothing else to print */
+			    else {
+				printf("d %d ", frame.can_dlc); /* data frame */
+
+				for (j = 0; j < frame.can_dlc; j++) {
+				    printf("%02X ", frame.data[j]);
+				}
+			    }
+			    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");
+			}
+		    }
+		    fflush(stdout);
+		}
+	    }
+	}
+    }
+
+    for (i=0; i<currmax; i++)
+	close(s[i]);
+
+    if (bridge)
+      close(bridge);
+
+    return 0;
+}
diff --git a/terminal.h b/terminal.h
new file mode 100644
index 0000000..0a440d3
--- /dev/null
+++ b/terminal.h
@@ -0,0 +1,99 @@
+/*
+ *  $Id: terminal.h,v 2.0 2006/04/13 10:37:21 ethuerm Exp $
+ */
+
+/*
+ * Copyright (c) 2002-2005 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'.
+ * 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.
+ * 3. Neither the name of Volkswagen nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * 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.
+ *
+ * The provided data structures and external interfaces from this code
+ * are not restricted to be used by modules with a GPL compatible license.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ * Send feedback to <llcf@volkswagen.de>
+ *
+ */
+
+#ifndef TERMINAL_H
+#define TERMINAL_H
+
+/* reset to default */
+
+#define ATTRESET "\33[0m"
+
+/* attributes */
+
+#define ATTBOLD      "\33[1m"
+#define ATTUNDERLINE "\33[4m"
+#define ATTBLINK     "\33[5m"
+#define ATTINVERSE   "\33[7m"
+#define ATTINVISIBLE "\33[8m"
+
+/* foreground colors */
+
+#define FGBLACK   "\33[30m"
+#define FGRED     "\33[31m"
+#define FGGREEN   "\33[32m"
+#define FGYELLOW  "\33[33m"
+#define FGBLUE    "\33[34m"
+#define FGMAGENTA "\33[35m"
+#define FGCYAN    "\33[36m"
+#define FGWHITE   "\33[37m"
+
+/* background colors */
+
+#define BGBLACK   "\33[40m"
+#define BGRED     "\33[41m"
+#define BGGREEN   "\33[42m"
+#define BGYELLOW  "\33[43m"
+#define BGBLUE    "\33[44m"
+#define BGMAGENTA "\33[45m"
+#define BGCYAN    "\33[46m"
+#define BGWHITE   "\33[47m"
+
+/* cursor */
+
+#define CSR_HOME  "\33[H"
+#define CSR_UP    "\33[A"
+#define CSR_DOWN  "\33[B"
+#define CSR_RIGHT "\33[C"
+#define CSR_LEFT  "\33[D"
+
+#define CSR_HIDE  "\33[?25l"
+#define CSR_SHOW  "\33[?25h"
+
+/* clear screen */
+
+#define CLR_SCREEN  "\33[2J"
+
+#endif /* TERMINAL_H */