bcmserver.c

   1 /*
   2  * tst-bcm-server.c
   3  *
   4  * Test programm that implements a socket server which understands ASCII
   5  * messages for simple broadcast manager frame send commands.
   6  *
   7  * < interface command ival_s ival_us can_id can_dlc [data]* >
   8  *
   9  * Only the items 'can_id' and 'data' are given in (ASCII) hexadecimal values.
  10  *
  11  * ## TX path:
  12  *
  13  * The commands are 'A'dd, 'U'pdate, 'D'elete and 'S'end.
  14  * e.g.
  15  *
  16  * Send the CAN frame 123#1122334455667788 every second on vcan1
  17  * < vcan1 A 1 0 123 8 11 22 33 44 55 66 77 88 >
  18  *
  19  * Send the CAN frame 123#1122334455667788 every 10 usecs on vcan1
  20  * < vcan1 A 0 10 123 8 11 22 33 44 55 66 77 88 >
  21  *
  22  * Send the CAN frame 123#42424242 every 20 msecs on vcan1
  23  * < vcan1 A 0 20000 123 4 42 42 42 42 >
  24  *
  25  * Update the CAN frame 123#42424242 with 123#112233 - no change of timers
  26  * < vcan1 U 0 0 123 3 11 22 33 >
  27  *
  28  * Delete the cyclic send job from above
  29  * < vcan1 D 0 0 123 0 >
  30  *
  31  * Send a single CAN frame without cyclic transmission
  32  * < can0 S 0 0 123 0 >
  33  *
  34  * When the socket is closed the cyclic transmissions are terminated.
  35  *
  36  * ## RX path:
  37  *
  38  * The commands are 'R'eceive setup, 'F'ilter ID Setup and 'X' for delete.
  39  * e.g.
  40  *
  41  * Receive CAN ID 0x123 from vcan1 and check for changes in the first byte
  42  * < vcan1 R 0 0 123 1 FF >
  43  *
  44  * Receive CAN ID 0x123 from vcan1 and check for changes in given mask
  45  * < vcan1 R 0 0 123 8 FF 00 F8 00 00 00 00 00 >
  46  *
  47  * As above but throttle receive update rate down to 1.5 seconds
  48  * < vcan1 R 1 500000 123 8 FF 00 F8 00 00 00 00 00 >
  49  *
  50  * Filter for CAN ID 0x123 from vcan1 without content filtering
  51  * < vcan1 F 0 0 123 0 >
  52  *
  53  * Delete receive filter ('R' or 'F') for CAN ID 0x123
  54  * < vcan1 X 0 0 123 0 >
  55  *
  56  * CAN messages received by the given filters are send in the format:
  57  * < interface can_id can_dlc [data]* >
  58  *
  59  * e.g. when receiving a CAN message from vcan1 with
  60  * can_id 0x123 , data length 4 and data 0x11, 0x22, 0x33 and 0x44
  61  *
  62  * < vcan1 123 4 11 22 33 44 >
  63  *
  64  * ##
  65  *
  66  * Authors:
  67  * Andre Naujoks (the socket server stuff)
  68  * Oliver Hartkopp (the rest)
  69  *
  70  * Copyright (c) 2002-2009 Volkswagen Group Electronic Research
  71  * All rights reserved.
  72  *
  73  * Redistribution and use in source and binary forms, with or without
  74  * modification, are permitted provided that the following conditions
  75  * are met:
  76  * 1. Redistributions of source code must retain the above copyright
  77  *    notice, this list of conditions and the following disclaimer.
  78  * 2. Redistributions in binary form must reproduce the above copyright
  79  *    notice, this list of conditions and the following disclaimer in the
  80  *    documentation and/or other materials provided with the distribution.
  81  * 3. Neither the name of Volkswagen nor the names of its contributors
  82  *    may be used to endorse or promote products derived from this software
  83  *    without specific prior written permission.
  84  *
  85  * Alternatively, provided that this notice is retained in full, this
  86  * software may be distributed under the terms of the GNU General
  87  * Public License ("GPL") version 2, in which case the provisions of the
  88  * GPL apply INSTEAD OF those given above.
  89  *
  90  * The provided data structures and external interfaces from this code
  91  * are not restricted to be used by modules with a GPL compatible license.
  92  *
  93  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  94  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  95  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  96  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  97  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  98  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  99  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 100  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 101  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 102  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 103  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 104  * DAMAGE.
 105  *
 106  * Send feedback to <linux-can@vger.kernel.org>
 107  *
 108  */
 109
 110 #include <stdio.h>
 111 #include <stdlib.h>
 112 #include <unistd.h>
 113 #include <string.h>
 114 #include <signal.h>
 115 #include <errno.h>
 116
 117 #include <sys/types.h>
 118 #include <sys/wait.h>
 119 #include <sys/socket.h>
 120 #include <sys/ioctl.h>
 121 #include <sys/uio.h>
 122 #include <net/if.h>
 123 #include <netinet/in.h>
 124
 125 #include <linux/can.h>
 126 #include <linux/can/bcm.h>
 127
 128 #define MAXLEN 100
 129 #define PORT 28600
 130
 131 void childdied(int i)
 132 {
 133         wait(NULL);
 134 }
 135
 136 int main(int argc, char **argv)
 137 {
 138
 139         int sl, sa, sc;
 140         int i;
 141         int idx = 0;
 142         struct sockaddr_in  saddr, clientaddr;
 143         struct sockaddr_can caddr;
 144         socklen_t caddrlen = sizeof(caddr);
 145         struct ifreq ifr;
 146         fd_set readfds;
 147         socklen_t sin_size = sizeof(clientaddr);
 148         struct sigaction signalaction;
 149         sigset_t sigset;
 150
 151         char buf[MAXLEN];
 152         char rxmsg[50];
 153
 154         struct {
 155                 struct bcm_msg_head msg_head;
 156                 struct can_frame frame;
 157         } msg;
 158
 159         sigemptyset(&sigset);
 160         signalaction.sa_handler = &childdied;
 161         signalaction.sa_mask = sigset;
 162         signalaction.sa_flags = 0;
 163         sigaction(SIGCHLD, &signalaction, NULL);  /* signal for dying child */
 164
 165         if((sl = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
 166                 perror("inetsocket");
 167                 exit(1);
 168         }
 169
 170         saddr.sin_family = AF_INET;
 171         saddr.sin_addr.s_addr = htonl(INADDR_ANY);
 172         saddr.sin_port = htons(PORT);
 173
 174         while(bind(sl,(struct sockaddr*)&saddr, sizeof(saddr)) < 0) {
 175                 printf(".");fflush(NULL);
 176                 usleep(100000);
 177         }
 178
 179         if (listen(sl,3) != 0) {
 180                 perror("listen");
 181                 exit(1);
 182         }
 183
 184         while (1) {
 185                 sa = accept(sl,(struct sockaddr *)&clientaddr, &sin_size);
 186                 if (sa > 0 ){
 187
 188                         if (fork())
 189                                 close(sa);
 190                         else
 191                                 break;
 192                 }
 193                 else {
 194                         if (errno != EINTR) {
 195                                 /*
 196                                  * If the cause for the error was NOT the
 197                                  * signal from a dying child => give an error
 198                                  */
 199                                 perror("accept");
 200                                 exit(1);
 201                         }
 202                 }
 203         }
 204
 205         /* open BCM socket */
 206
 207         if ((sc = socket(PF_CAN, SOCK_DGRAM, CAN_BCM)) < 0) {
 208                 perror("bcmsocket");
 209                 return 1;
 210         }
 211
 212         memset(&caddr, 0, sizeof(caddr));
 213         caddr.can_family = PF_CAN;
 214         /* can_ifindex is set to 0 (any device) => need for sendto() */
 215
 216         if (connect(sc, (struct sockaddr *)&caddr, sizeof(caddr)) < 0) {
 217                 perror("connect");
 218                 return 1;
 219         }
 220
 221         while (1) {
 222
 223                 FD_ZERO(&readfds);
 224                 FD_SET(sc, &readfds);
 225                 FD_SET(sa, &readfds);
 226
 227                 select((sc > sa)?sc+1:sa+1, &readfds, NULL, NULL, NULL);
 228
 229                 if (FD_ISSET(sc, &readfds)) {
 230
 231                         recvfrom(sc, &msg, sizeof(msg), 0,
 232                                  (struct sockaddr*)&caddr, &caddrlen);
 233
 234                         ifr.ifr_ifindex = caddr.can_ifindex;
 235                         ioctl(sc, SIOCGIFNAME, &ifr);
 236
 237                         sprintf(rxmsg, "< %s %03X %d ", ifr.ifr_name,
 238                                 msg.msg_head.can_id, msg.frame.can_dlc);
 239
 240                         for ( i = 0; i < msg.frame.can_dlc; i++)
 241                                 sprintf(rxmsg + strlen(rxmsg), "%02X ",
 242                                         msg.frame.data[i]);
 243
 244                         /* delimiter '\0' for Adobe(TM) Flash(TM) XML sockets */
 245                         strcat(rxmsg, ">\0");
 246
 247                         send(sa, rxmsg, strlen(rxmsg) + 1, 0);
 248                 }
 249
 250
 251                 if (FD_ISSET(sa, &readfds)) {
 252
 253                         char cmd;
 254                         int items;
 255
 256                         if (read(sa, buf+idx, 1) < 1)
 257                                 exit(1);
 258
 259                         if (!idx) {
 260                                 if (buf[0] == '<')
 261                                         idx = 1;
 262
 263                                 continue;
 264                         }
 265
 266                         if (idx > MAXLEN-2) {
 267                                 idx = 0;
 268                                 continue;
 269                         }
 270
 271                         if (buf[idx] != '>') {
 272                                 idx++;
 273                                 continue;
 274                         }
 275
 276                         buf[idx+1] = 0;
 277                         idx = 0;
 278
 279                         //printf("read '%s'\n", buf);
 280
 281                         /* prepare bcm message settings */
 282                         memset(&msg, 0, sizeof(msg));
 283                         msg.msg_head.nframes = 1;
 284
 285                         items = sscanf(buf, "< %6s %c %lu %lu %x %hhu "
 286                                        "%hhx %hhx %hhx %hhx %hhx %hhx "
 287                                        "%hhx %hhx >",
 288                                        ifr.ifr_name,
 289                                        &cmd,
 290                                        &msg.msg_head.ival2.tv_sec,
 291                                        &msg.msg_head.ival2.tv_usec,
 292                                        &msg.msg_head.can_id,
 293                                        &msg.frame.can_dlc,
 294                                        &msg.frame.data[0],
 295                                        &msg.frame.data[1],
 296                                        &msg.frame.data[2],
 297                                        &msg.frame.data[3],
 298                                        &msg.frame.data[4],
 299                                        &msg.frame.data[5],
 300                                        &msg.frame.data[6],
 301                                        &msg.frame.data[7]);
 302
 303                         if (items < 6)
 304                                 break;
 305                         if (msg.frame.can_dlc > 8)
 306                                 break;
 307                         if (items != 6 + msg.frame.can_dlc)
 308                                 break;
 309
 310                         msg.frame.can_id = msg.msg_head.can_id;
 311
 312                         switch (cmd) {
 313                         case 'S':
 314                                 msg.msg_head.opcode = TX_SEND;
 315                                 break;
 316                         case 'A':
 317                                 msg.msg_head.opcode = TX_SETUP;
 318                                 msg.msg_head.flags |= SETTIMER | STARTTIMER;
 319                                 break;
 320                         case 'U':
 321                                 msg.msg_head.opcode = TX_SETUP;
 322                                 msg.msg_head.flags  = 0;
 323                                 break;
 324                         case 'D':
 325                                 msg.msg_head.opcode = TX_DELETE;
 326                                 break;
 327
 328                         case 'R':
 329                                 msg.msg_head.opcode = RX_SETUP;
 330                                 msg.msg_head.flags  = SETTIMER;
 331                                 break;
 332                         case 'F':
 333                                 msg.msg_head.opcode = RX_SETUP;
 334                                 msg.msg_head.flags  = RX_FILTER_ID | SETTIMER;
 335                                 break;
 336                         case 'X':
 337                                 msg.msg_head.opcode = RX_DELETE;
 338                                 break;
 339                         default:
 340                                 printf("unknown command '%c'.\n", cmd);
 341                                 exit(1);
 342                         }
 343
 344                         if (!ioctl(sc, SIOCGIFINDEX, &ifr)) {
 345                                 caddr.can_ifindex = ifr.ifr_ifindex;
 346                                 sendto(sc, &msg, sizeof(msg), 0,
 347                                        (struct sockaddr*)&caddr, sizeof(caddr));
 348                         }
 349                 }
 350         }
 351
 352         close(sc);
 353         close(sa);
 354
 355         return 0;
 356 }