test/tst-bcm-filter.c

   1 /*
   2  *  $Id$
   3  */
   4
   5 /*
   6  * tst-bcm-filter.c
   7  *
   8  * Copyright (c) 2002-2007 Volkswagen Group Electronic Research
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. Neither the name of Volkswagen nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * Alternatively, provided that this notice is retained in full, this
  24  * software may be distributed under the terms of the GNU General
  25  * Public License ("GPL") version 2, in which case the provisions of the
  26  * GPL apply INSTEAD OF those given above.
  27  *
  28  * The provided data structures and external interfaces from this code
  29  * are not restricted to be used by modules with a GPL compatible license.
  30  *
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  36  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  37  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  38  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  39  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  40  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  41  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  42  * DAMAGE.
  43  *
  44  * Send feedback to <socketcan-users@lists.berlios.de>
  45  *
  46  */
  47
  48 #include <stdio.h>
  49 #include <stdlib.h>
  50 #include <unistd.h>
  51 #include <string.h>
  52
  53 #include <sys/types.h>
  54 #include <sys/socket.h>
  55 #include <sys/ioctl.h>
  56 #include <sys/uio.h>
  57 #include <net/if.h>
  58
  59 #include <linux/can.h>
  60 #include <linux/can/bcm.h>
  61
  62 #define U64_DATA(p) (*(unsigned long long*)(p)->data)
  63
  64 int main(int argc, char **argv)
  65 {
  66     int s,nbytes;
  67     struct sockaddr_can addr;
  68     struct ifreq ifr;
  69
  70     struct timeval tv;
  71
  72     struct {
  73       struct bcm_msg_head msg_head;
  74       struct can_frame frame[4];
  75     } txmsg, rxmsg;
  76
  77     if ((s = socket(PF_CAN, SOCK_DGRAM, CAN_BCM)) < 0) {
  78         perror("socket");
  79         return 1;
  80     }
  81
  82     addr.can_family = PF_CAN;
  83     strcpy(ifr.ifr_name, "vcan2");
  84     ioctl(s, SIOCGIFINDEX, &ifr);
  85     addr.can_ifindex = ifr.ifr_ifindex;
  86
  87     if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
  88         perror("connect");
  89         return 1;
  90     }
  91
  92     txmsg.msg_head.opcode  = RX_SETUP;
  93     txmsg.msg_head.can_id  = 0x042;
  94     txmsg.msg_head.flags   = SETTIMER|RX_FILTER_ID;
  95     txmsg.msg_head.ival1.tv_sec = 1;
  96     txmsg.msg_head.ival1.tv_usec = 0;
  97     txmsg.msg_head.ival2.tv_sec = 0;
  98     txmsg.msg_head.ival2.tv_usec = 0;
  99     txmsg.msg_head.nframes = 0;
 100
 101     printf("<*>Writing RX_SETUP with RX_FILTER_ID for can_id <%03X>\n",
 102            txmsg.msg_head.can_id);
 103
 104     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 105       perror("write");
 106
 107     /* test for RX_DELETE */
 108     txmsg.msg_head.opcode  = RX_DELETE;
 109     txmsg.msg_head.can_id  = 0x042; /* everything we need for RX_DELETE */
 110
 111     printf("<*>Writing RX_DELETE for can_id <%03X>\n",
 112            txmsg.msg_head.can_id);
 113
 114     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 115       perror("write");
 116
 117     txmsg.msg_head.opcode  = RX_SETUP;
 118     txmsg.msg_head.can_id  = 0x042;
 119     txmsg.msg_head.flags   = SETTIMER|RX_FILTER_ID;
 120     txmsg.msg_head.ival1.tv_sec = 1;
 121     txmsg.msg_head.ival1.tv_usec = 0;
 122     txmsg.msg_head.ival2.tv_sec = 0;
 123     txmsg.msg_head.ival2.tv_usec = 0;
 124     txmsg.msg_head.nframes = 0;
 125
 126     printf("<*>Writing RX_SETUP with RX_FILTER_ID for can_id <%03X>\n",
 127            txmsg.msg_head.can_id);
 128
 129     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 130       perror("write");
 131
 132     txmsg.msg_head.opcode  = TX_SEND;
 133     txmsg.msg_head.nframes = 1;
 134     /* obsolete for TX_SEND ... */
 135 #if 0
 136     txmsg.msg_head.can_id  = 0x43;
 137     txmsg.msg_head.flags   = SETTIMER|STARTTIMER|TX_CP_CAN_ID;
 138     txmsg.msg_head.count = 0;
 139     txmsg.msg_head.ival1.tv_sec = 0;
 140     txmsg.msg_head.ival1.tv_usec = 0;
 141     txmsg.msg_head.ival2.tv_sec = 0;
 142     txmsg.msg_head.ival2.tv_usec = 0;
 143 #endif
 144     txmsg.frame[0].can_id    = 0x43;
 145     txmsg.frame[0].can_dlc   = 8;
 146     U64_DATA(&txmsg.frame[0]) = (__u64) 0xdeadbeefdeadbeefULL;
 147
 148     printf("<2>Writing TX_SEND with wrong can_id <%03X>\n",
 149            txmsg.frame[0].can_id);
 150
 151     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 152       perror("write");
 153
 154     txmsg.msg_head.opcode  = TX_SEND;
 155     txmsg.msg_head.nframes = 1;
 156     txmsg.frame[0].can_id    = 0x42;
 157     txmsg.frame[0].can_dlc   = 8;
 158     U64_DATA(&txmsg.frame[0]) = (__u64) 0xdeadbeefdeadbeefULL;
 159
 160     printf("<3>Writing TX_SEND with correct can_id <%03X>\n",
 161            txmsg.frame[0].can_id);
 162
 163     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 164       perror("write");
 165
 166     if ((nbytes = read(s, &rxmsg, sizeof(rxmsg))) < 0)
 167       perror("read");
 168
 169     ioctl(s, SIOCGSTAMP, &tv);
 170     printf("(%ld.%06ld)   ", tv.tv_sec, tv.tv_usec);
 171
 172     if (rxmsg.msg_head.opcode == RX_CHANGED &&
 173         nbytes == sizeof(struct bcm_msg_head) + sizeof(struct can_frame) &&
 174         rxmsg.msg_head.can_id == 0x42 && rxmsg.frame[0].can_id == 0x42) {
 175       printf("<3>Received correct RX_CHANGED message for can_id <%03X> >> OK!\n",
 176              rxmsg.frame[0].can_id);
 177     }
 178
 179     /* growing number of nframes => RX_DELETE instead of simple update */
 180     txmsg.msg_head.opcode  = RX_DELETE;
 181     txmsg.msg_head.can_id  = 0x042; /* everything we need for RX_DELETE */
 182
 183     printf("<*>Writing RX_DELETE for can_id <%03X>\n",
 184            txmsg.msg_head.can_id);
 185
 186     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 187       perror("write");
 188
 189     txmsg.msg_head.opcode  = RX_SETUP;
 190     txmsg.msg_head.can_id  = 0x042;
 191     txmsg.msg_head.flags   = SETTIMER|RX_CHECK_DLC;
 192     txmsg.msg_head.ival1.tv_sec = 1;
 193     txmsg.msg_head.ival1.tv_usec = 0;
 194     txmsg.msg_head.ival2.tv_sec = 0;
 195     txmsg.msg_head.ival2.tv_usec = 0;
 196     txmsg.msg_head.nframes = 1;
 197     /* txmsg.frame[0].can_dlc   = 8; obsolete for RX_SETUP */
 198     U64_DATA(&txmsg.frame[0]) = (__u64) 0xFF00000000000000ULL;
 199
 200     printf("<*>Writing simple RX_SETUP for can_id <%03X> with msgbits 0x%016llX\n",
 201            txmsg.msg_head.can_id, U64_DATA(&txmsg.frame[0]));
 202
 203     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 204       perror("write");
 205
 206     txmsg.msg_head.opcode  = TX_SEND;
 207     txmsg.msg_head.nframes = 1;
 208     txmsg.frame[0].can_id    = 0x42;
 209     txmsg.frame[0].can_dlc   = 8;
 210     U64_DATA(&txmsg.frame[0]) = (__u64) 0xdeadbeefdeadbeefULL;
 211
 212     printf("<5>Writing TX_SEND with correct can_id <%03X>\n",
 213            txmsg.frame[0].can_id);
 214
 215     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 216       perror("write");
 217
 218     if ((nbytes = read(s, &rxmsg, sizeof(rxmsg))) < 0)
 219       perror("read");
 220
 221     ioctl(s, SIOCGSTAMP, &tv);
 222     printf("(%ld.%06ld)   ", tv.tv_sec, tv.tv_usec);
 223
 224     if (rxmsg.msg_head.opcode == RX_CHANGED &&
 225         nbytes == sizeof(struct bcm_msg_head) + sizeof(struct can_frame) &&
 226         rxmsg.msg_head.can_id == 0x42 && rxmsg.frame[0].can_id == 0x42) {
 227       printf("<5>Received correct RX_CHANGED message for can_id <%03X> >> OK!\n",
 228              rxmsg.frame[0].can_id);
 229     }
 230
 231     txmsg.msg_head.opcode  = TX_SEND;
 232     txmsg.msg_head.nframes = 1;
 233     txmsg.frame[0].can_id    = 0x42;
 234     txmsg.frame[0].can_dlc   = 8;
 235     U64_DATA(&txmsg.frame[0]) = (__u64) 0xdeadbeefdeadbeefULL;
 236
 237     printf("<6>Writing TX_SEND with correct can_id <%03X> ",
 238            txmsg.frame[0].can_id);
 239     printf("no changed data\n");
 240
 241     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 242       perror("write");
 243
 244     /* no change here */
 245
 246     txmsg.msg_head.opcode  = TX_SEND;
 247     txmsg.msg_head.nframes = 1;
 248     txmsg.frame[0].can_id    = 0x42;
 249     txmsg.frame[0].can_dlc   = 8;
 250     U64_DATA(&txmsg.frame[0]) = (__u64) 0xdeadbeefdeadbeefULL;
 251
 252     printf("<7>Writing TX_SEND with correct can_id <%03X> ",
 253            txmsg.frame[0].can_id);
 254     printf("changed relevant msgbits\n");
 255
 256     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 257       perror("write");
 258
 259     if ((nbytes = read(s, &rxmsg, sizeof(rxmsg))) < 0)
 260       perror("read");
 261
 262     ioctl(s, SIOCGSTAMP, &tv);
 263     printf("(%ld.%06ld)   ", tv.tv_sec, tv.tv_usec);
 264
 265     if (rxmsg.msg_head.opcode == RX_CHANGED &&
 266         nbytes == sizeof(struct bcm_msg_head) + sizeof(struct can_frame) &&
 267         rxmsg.msg_head.can_id == 0x42 && rxmsg.frame[0].can_id == 0x42) {
 268       printf("<7>Received correct RX_CHANGED message for can_id <%03X> >> OK!\n",
 269              rxmsg.frame[0].can_id);
 270     }
 271
 272     txmsg.msg_head.opcode  = TX_SEND;
 273     txmsg.msg_head.nframes = 1;
 274     txmsg.frame[0].can_id    = 0x42;
 275     txmsg.frame[0].can_dlc   = 8;
 276     U64_DATA(&txmsg.frame[0]) = (__u64) 0xdeadbeefdeadbeefULL;
 277
 278     printf("<8>Writing TX_SEND with correct can_id <%03X> ",
 279            txmsg.frame[0].can_id);
 280     printf("changed irrelevant msgbits\n");
 281
 282     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 283       perror("write");
 284
 285     txmsg.msg_head.opcode  = TX_SEND;
 286     txmsg.msg_head.nframes = 1;
 287     txmsg.frame[0].can_id    = 0x42;
 288     txmsg.frame[0].can_dlc   = 7;
 289     U64_DATA(&txmsg.frame[0]) = (__u64) 0xdeadbeefdeadbeefULL;
 290
 291     printf("<9>Writing TX_SEND with correct can_id <%03X> ",
 292            txmsg.frame[0].can_id);
 293     printf("changed Data Length Code DLC\n");
 294
 295     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 296       perror("write");
 297
 298     if ((nbytes = read(s, &rxmsg, sizeof(rxmsg))) < 0)
 299       perror("read");
 300
 301     ioctl(s, SIOCGSTAMP, &tv);
 302     printf("(%ld.%06ld)   ", tv.tv_sec, tv.tv_usec);
 303
 304     if (rxmsg.msg_head.opcode == RX_CHANGED &&
 305         nbytes == sizeof(struct bcm_msg_head) + sizeof(struct can_frame) &&
 306         rxmsg.msg_head.can_id == 0x42 && rxmsg.frame[0].can_id == 0x42) {
 307       printf("<9>Received correct RX_CHANGED message for can_id <%03X> >> OK!\n",
 308              rxmsg.frame[0].can_id);
 309     }
 310
 311     txmsg.msg_head.opcode  = RX_DELETE;
 312     txmsg.msg_head.can_id  = 0x042; /* everything we need for RX_DELETE */
 313
 314     printf("<*>Writing RX_DELETE for can_id <%03X> for RX_SETUP with growing nframes\n",
 315            txmsg.msg_head.can_id);
 316
 317     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 318       perror("write");
 319
 320     /* no problems ;-) but NOW we try MUX messages ... and timeouts */
 321
 322     txmsg.msg_head.opcode  = RX_SETUP;
 323     txmsg.msg_head.can_id  = 0x042;
 324     txmsg.msg_head.flags   = SETTIMER|RX_CHECK_DLC;
 325     txmsg.msg_head.ival1.tv_sec = 1;
 326     txmsg.msg_head.ival1.tv_usec = 0;
 327     txmsg.msg_head.nframes = 3;
 328     U64_DATA(&txmsg.frame[0]) = (__u64) 0xFF00000000000000ULL;
 329     U64_DATA(&txmsg.frame[1]) = (__u64) 0x01000000000000FFULL;
 330     U64_DATA(&txmsg.frame[2]) = (__u64) 0x02000000000000FFULL;
 331
 332     printf("<*>Writing multiplex RX_SETUP for can_id <%03X>\n",
 333            txmsg.msg_head.can_id);
 334
 335     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 336       perror("write");
 337
 338
 339     txmsg.msg_head.opcode  = TX_SEND;
 340     txmsg.msg_head.nframes = 1;
 341     txmsg.frame[0].can_id    = 0x42;
 342     txmsg.frame[0].can_dlc   = 8;
 343     U64_DATA(&txmsg.frame[0]) = (__u64) 0x4200000000000000ULL;
 344
 345     printf("<A>Writing TX_SEND with wrong MUX ID 42\n");
 346
 347     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 348       perror("write");
 349
 350     txmsg.msg_head.opcode  = TX_SEND;
 351     txmsg.msg_head.nframes = 1;
 352     txmsg.frame[0].can_id    = 0x42;
 353     txmsg.frame[0].can_dlc   = 8;
 354     U64_DATA(&txmsg.frame[0]) = (__u64) 0x0100000000000000ULL;
 355
 356     printf("<B>Writing TX_SEND with correct MUX ID 01\n");
 357
 358     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 359       perror("write");
 360
 361     if ((nbytes = read(s, &rxmsg, sizeof(rxmsg))) < 0)
 362       perror("read");
 363
 364     ioctl(s, SIOCGSTAMP, &tv);
 365     printf("(%ld.%06ld)   ", tv.tv_sec, tv.tv_usec);
 366
 367     if (rxmsg.msg_head.opcode == RX_CHANGED &&
 368         nbytes == sizeof(struct bcm_msg_head) + sizeof(struct can_frame) &&
 369         rxmsg.msg_head.can_id == 0x42 && rxmsg.frame[0].can_id == 0x42) {
 370       printf("<B>Received correct RX_CHANGED message for can_id <%03X> >> OK!\n",
 371              rxmsg.frame[0].can_id);
 372     }
 373
 374     txmsg.msg_head.opcode  = TX_SEND;
 375     txmsg.msg_head.nframes = 1;
 376     txmsg.frame[0].can_id    = 0x42;
 377     txmsg.frame[0].can_dlc   = 8;
 378     U64_DATA(&txmsg.frame[0]) = (__u64) 0x0100000000000000ULL;
 379
 380     printf("<C>Writing TX_SEND with correct MUX ID 01 but no data change\n");
 381
 382     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 383       perror("write");
 384
 385     txmsg.msg_head.opcode  = TX_SEND;
 386     txmsg.msg_head.nframes = 1;
 387     txmsg.frame[0].can_id    = 0x42;
 388     txmsg.frame[0].can_dlc   = 8;
 389     U64_DATA(&txmsg.frame[0]) = (__u64) 0x0100001234567800ULL;
 390
 391     printf("<D>Writing TX_SEND with correct MUX ID 01 but no relevant data change\n");
 392
 393     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 394       perror("write");
 395
 396     txmsg.msg_head.opcode  = TX_SEND;
 397     txmsg.msg_head.nframes = 1;
 398     txmsg.frame[0].can_id    = 0x42;
 399     txmsg.frame[0].can_dlc   = 8;
 400     U64_DATA(&txmsg.frame[0]) = (__u64) 0x0100001234567801ULL;
 401
 402     printf("<E>Writing TX_SEND with correct MUX ID 01 with relevant data change\n");
 403
 404     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 405       perror("write");
 406
 407     if ((nbytes = read(s, &rxmsg, sizeof(rxmsg))) < 0)
 408       perror("read");
 409
 410     ioctl(s, SIOCGSTAMP, &tv);
 411     printf("(%ld.%06ld)   ", tv.tv_sec, tv.tv_usec);
 412
 413     if (rxmsg.msg_head.opcode == RX_CHANGED &&
 414         nbytes == sizeof(struct bcm_msg_head) + sizeof(struct can_frame) &&
 415         rxmsg.msg_head.can_id == 0x42 && rxmsg.frame[0].can_id == 0x42) {
 416       printf("<E>Received correct RX_CHANGED message for can_id <%03X> >> OK!\n",
 417              rxmsg.frame[0].can_id);
 418     }
 419
 420     txmsg.msg_head.opcode  = TX_SEND;
 421     txmsg.msg_head.nframes = 1;
 422     txmsg.frame[0].can_id    = 0x42;
 423     txmsg.frame[0].can_dlc   = 8;
 424     U64_DATA(&txmsg.frame[0]) = (__u64) 0x0200000000000000ULL;
 425
 426     printf("<F>Writing TX_SEND with correct MUX ID 02\n");
 427
 428     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 429       perror("write");
 430
 431     if ((nbytes = read(s, &rxmsg, sizeof(rxmsg))) < 0)
 432       perror("read");
 433
 434     ioctl(s, SIOCGSTAMP, &tv);
 435     printf("(%ld.%06ld)   ", tv.tv_sec, tv.tv_usec);
 436
 437     if (rxmsg.msg_head.opcode == RX_CHANGED &&
 438         nbytes == sizeof(struct bcm_msg_head) + sizeof(struct can_frame) &&
 439         rxmsg.msg_head.can_id == 0x42 && rxmsg.frame[0].can_id == 0x42) {
 440       printf("<F>Received correct RX_CHANGED message for can_id <%03X> >> OK!\n",
 441              rxmsg.frame[0].can_id);
 442     }
 443
 444     txmsg.msg_head.opcode  = TX_SEND;
 445     txmsg.msg_head.nframes = 1;
 446     txmsg.frame[0].can_id    = 0x42;
 447     txmsg.frame[0].can_dlc   = 8;
 448     U64_DATA(&txmsg.frame[0]) = (__u64) 0x0200000000000001ULL;
 449
 450     printf("<10>Writing TX_SEND with correct MUX ID 02 with relevant data change\n");
 451
 452     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 453       perror("write");
 454
 455     if ((nbytes = read(s, &rxmsg, sizeof(rxmsg))) < 0)
 456       perror("read");
 457
 458     ioctl(s, SIOCGSTAMP, &tv);
 459     printf("(%ld.%06ld)   ", tv.tv_sec, tv.tv_usec);
 460
 461     if (rxmsg.msg_head.opcode == RX_CHANGED &&
 462         nbytes == sizeof(struct bcm_msg_head) + sizeof(struct can_frame) &&
 463         rxmsg.msg_head.can_id == 0x42 && rxmsg.frame[0].can_id == 0x42) {
 464       printf("<10>Received correct RX_CHANGED message for can_id <%03X> >> OK!\n",
 465              rxmsg.frame[0].can_id);
 466     }
 467
 468     txmsg.msg_head.opcode  = TX_SEND;
 469     txmsg.msg_head.nframes = 1;
 470     txmsg.frame[0].can_id    = 0x42;
 471     txmsg.frame[0].can_dlc   = 7;
 472     U64_DATA(&txmsg.frame[0]) = (__u64) 0x0200000000000001ULL;
 473
 474     printf("<11>Writing TX_SEND with correct MUX ID 02 no data change but DLC\n");
 475
 476     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 477       perror("write");
 478
 479     if ((nbytes = read(s, &rxmsg, sizeof(rxmsg))) < 0)
 480       perror("read");
 481
 482     if (rxmsg.msg_head.opcode == RX_CHANGED &&
 483         nbytes == sizeof(struct bcm_msg_head) + sizeof(struct can_frame) &&
 484         rxmsg.msg_head.can_id == 0x42 && rxmsg.frame[0].can_id == 0x42) {
 485       printf("<11>Received correct RX_CHANGED message for can_id <%03X> >> OK!\n",
 486              rxmsg.frame[0].can_id);
 487     }
 488
 489     txmsg.msg_head.opcode  = TX_SEND;
 490     txmsg.msg_head.nframes = 1;
 491     txmsg.frame[0].can_id    = 0x42;
 492     txmsg.frame[0].can_dlc   = 7;
 493     U64_DATA(&txmsg.frame[0]) = (__u64) 0x0300000000000001ULL;
 494
 495     printf("<12>Writing TX_SEND with wrong MUX ID 03\n");
 496
 497     if (write(s, &txmsg, sizeof(txmsg)) < 0)
 498       perror("write");
 499
 500     if ((nbytes = read(s, &rxmsg, sizeof(rxmsg))) < 0)
 501       perror("read");
 502
 503     ioctl(s, SIOCGSTAMP, &tv);
 504     printf("(%ld.%06ld)   ", tv.tv_sec, tv.tv_usec);
 505
 506     if (rxmsg.msg_head.opcode == RX_TIMEOUT &&
 507         nbytes == sizeof(struct bcm_msg_head) &&
 508         rxmsg.msg_head.can_id == 0x42) {
 509       printf("<-->Received correct RX_TIMEOUT message for can_id <%03X> >> OK!\n",
 510              rxmsg.msg_head.can_id);
 511     }
 512
 513     close(s);
 514
 515     return 0;
 516 }