Initial packaging.
[profile/ivi/can-utils.git] / 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 }