]> rtime.felk.cvut.cz Git - can-utils.git/blob - slcand.c
slcand: fix whitespace issues and unify coding style
[can-utils.git] / slcand.c
1 /*
2  * slcand.c - userspace daemon for serial line CAN interface driver SLCAN
3  *
4  * Copyright (c) 2009 Robert Haddon <robert.haddon@verari.com>
5  * Copyright (c) 2009 Verari Systems Inc.
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  *
21  * This code is derived from an example daemon code from
22  *
23  * http://en.wikipedia.org/wiki/Daemon_(computer_software)#Sample_Program_in_C_on_Linux
24  * (accessed 2009-05-05)
25  *
26  * So it is additionally licensed under the GNU Free Documentation License:
27  *
28  * Permission is granted to copy, distribute and/or modify this document
29  * under the terms of the GNU Free Documentation License, Version 1.2
30  * or any later version published by the Free Software Foundation;
31  * with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
32  * A copy of the license is included in the section entitled "GNU
33  * Free Documentation License".
34  *
35  * Send feedback to <linux-can@vger.kernel.org>
36  *
37  */
38
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <string.h>
42 #include <unistd.h>
43 #include <sys/types.h>
44 #include <sys/stat.h>
45 #include <fcntl.h>
46 #include <syslog.h>
47 #include <errno.h>
48 #include <pwd.h>
49 #include <signal.h>
50 #include <sys/ioctl.h>
51 #include <net/if.h>
52 #include <termios.h>
53
54 /* default slcan line discipline since Kernel 2.6.25 */
55 #define LDISC_N_SLCAN 17
56
57 /* Change this to whatever your daemon is called */
58 #define DAEMON_NAME "slcand"
59
60 /* Change this to the user under which to run */
61 #define RUN_AS_USER "root"
62
63 /* The length of ttypath buffer */
64 #define TTYPATH_LENGTH  64
65
66 /* The length of pidfile name buffer */
67 #define PIDFILE_LENGTH  64
68
69 #define EXIT_SUCCESS 0
70 #define EXIT_FAILURE 1
71
72 void print_usage(char *prg)
73 {
74         fprintf(stderr, "\nUsage: %s [options] <tty> [canif-name]\n\n", prg);
75         fprintf(stderr, "Options: -o         (send open command 'O\\r')\n");
76         fprintf(stderr, "         -c         (send close command 'C\\r')\n");
77         fprintf(stderr, "         -f         (read status flags with 'F\\r' to reset error states)\n");
78         fprintf(stderr, "         -s <speed> (set CAN speed 0..8)\n");
79         fprintf(stderr, "         -S <speed> (set UART speed in baud)\n");
80         fprintf(stderr, "         -b <btr>   (set bit time register value)\n");
81         fprintf(stderr, "         -F         (stay in foreground; no daemonize)\n");
82         fprintf(stderr, "         -h         (show this help page)\n");
83         fprintf(stderr, "\nExamples:\n");
84         fprintf(stderr, "slcand -o -c -f -s6 ttyslcan0\n");
85         fprintf(stderr, "slcand -o -c -f -s6 ttyslcan0 can0\n");
86         fprintf(stderr, "\n");
87         exit(EXIT_FAILURE);
88 }
89
90 static int slcand_running;
91 static int exit_code;
92 static char ttypath[TTYPATH_LENGTH];
93 static char pidfile[PIDFILE_LENGTH];
94
95 static void child_handler(int signum)
96 {
97         switch (signum) {
98
99         case SIGUSR1:
100                 /* exit parent */
101                 exit(EXIT_SUCCESS);
102                 break;
103         case SIGALRM:
104         case SIGCHLD:
105                 syslog(LOG_NOTICE, "received signal %i on %s", signum, ttypath);
106                 exit_code = EXIT_FAILURE;
107                 slcand_running = 0;
108                 break;
109         case SIGINT:
110         case SIGTERM:
111                 syslog(LOG_NOTICE, "received signal %i on %s", signum, ttypath);
112                 exit_code = EXIT_SUCCESS;
113                 slcand_running = 0;
114                 break;
115         }
116 }
117
118 static int look_up_uart_speed(long int s)
119 {
120         switch (s) {
121
122         case 9600:
123                 return B9600;
124         case 19200:
125                 return B19200;
126         case 38400:
127                 return B38400;
128         case 57600:
129                 return B57600;
130         case 115200:
131                 return B115200;
132         case 230400:
133                 return B230400;
134         case 460800:
135                 return B460800;
136         case 500000:
137                 return B500000;
138         case 576000:
139                 return B576000;
140         case 921600:
141                 return B921600;
142         case 1000000:
143                 return B1000000;
144         case 1152000:
145                 return B1152000;
146         case 1500000:
147                 return B1500000;
148         case 2000000:
149                 return B2000000;
150 #ifdef B2500000
151         case 2500000:
152                 return B2500000;
153 #endif
154 #ifdef B3000000
155         case 3000000:
156                 return B3000000;
157 #endif
158 #ifdef B3500000
159         case 3500000:
160                 return B3500000;
161 #endif
162 #ifdef B3710000
163         case 3710000
164                 return B3710000;
165 #endif
166 #ifdef B4000000
167         case 4000000:
168                 return B4000000;
169 #endif
170         default:
171                 return -1;
172         }
173 }
174
175 static pid_t daemonize(const char *lockfile, char *tty, char *name)
176 {
177         pid_t pid, sid, parent;
178         int lfp = -1;
179         FILE *pFile;
180         FILE *dummyFile;
181         char const *pidprefix = "/var/run/";
182         char const *pidsuffix = ".pid";
183
184         snprintf(pidfile, PIDFILE_LENGTH, "%s%s-%s%s", pidprefix, DAEMON_NAME, tty, pidsuffix);
185
186         /* already a daemon */
187         if (getppid() == 1)
188                 return 0;
189
190         /* Create the lock file as the current user */
191         if (lockfile && lockfile[0]) {
192
193                 lfp = open(lockfile, O_RDWR | O_CREAT, 0640);
194                 if (lfp < 0)
195                 {
196                         syslog(LOG_ERR, "unable to create lock file %s, code=%d (%s)",
197                                lockfile, errno, strerror(errno));
198                         exit(EXIT_FAILURE);
199                 }
200         }
201
202         /* Drop user if there is one, and we were run as root */
203         if (getuid() == 0 || geteuid() == 0) {
204                 struct passwd *pw = getpwnam(RUN_AS_USER);
205
206                 if (pw)
207                 {
208                         /* syslog(LOG_NOTICE, "setting user to " RUN_AS_USER); */
209                         setuid(pw->pw_uid);
210                 }
211         }
212
213         /* Trap signals that we expect to receive */
214         signal(SIGINT, child_handler);
215         signal(SIGTERM, child_handler);
216         signal(SIGCHLD, child_handler);
217         signal(SIGUSR1, child_handler);
218         signal(SIGALRM, child_handler);
219
220         /* Fork off the parent process */
221         pid = fork();
222         if (pid < 0) {
223                 syslog(LOG_ERR, "unable to fork daemon, code=%d (%s)",
224                        errno, strerror(errno));
225                 exit(EXIT_FAILURE);
226         }
227
228         /* If we got a good PID, then we can exit the parent process. */
229         if (pid > 0) {
230                 /* Wait for confirmation from the child via SIGTERM or SIGCHLD, or
231                    for five seconds to elapse (SIGALRM).  pause() should not return. */
232                 alarm(5);
233                 pause();
234                 exit(EXIT_FAILURE);
235         }
236
237         /* At this point we are executing as the child process */
238         parent = getppid();
239
240         /* Cancel certain signals */
241         signal(SIGCHLD, SIG_DFL);       /* A child process dies */
242         signal(SIGTSTP, SIG_IGN);       /* Various TTY signals */
243         signal(SIGTTOU, SIG_IGN);
244         signal(SIGTTIN, SIG_IGN);
245         signal(SIGHUP, SIG_IGN);        /* Ignore hangup signal */
246         signal(SIGINT, child_handler);
247         signal(SIGTERM, child_handler);
248
249         /* Change the file mode mask */
250         umask(0);
251
252         /* Create a new SID for the child process */
253         sid = setsid();
254         if (sid < 0) {
255                 syslog(LOG_ERR, "unable to create a new session, code %d (%s)",
256                        errno, strerror(errno));
257                 exit(EXIT_FAILURE);
258         }
259
260         pFile = fopen(pidfile, "w");
261         if (NULL == pFile) {
262                 syslog(LOG_ERR, "unable to create pid file %s, code=%d (%s)",
263                        pidfile, errno, strerror(errno));
264                 exit(EXIT_FAILURE);
265         }
266         fprintf(pFile, "%d\n", sid);
267         fclose(pFile);
268
269         /* Change the current working directory.  This prevents the current
270            directory from being locked; hence not being able to remove it. */
271         if (chdir("/") < 0) {
272                 syslog(LOG_ERR, "unable to change directory to %s, code %d (%s)",
273                        "/", errno, strerror(errno));
274                 exit(EXIT_FAILURE);
275         }
276
277         /* Redirect standard files to /dev/null */
278         dummyFile = freopen("/dev/null", "r", stdin);
279         dummyFile = freopen("/dev/null", "w", stdout);
280         dummyFile = freopen("/dev/null", "w", stderr);
281
282         /* Tell the parent process that we are A-okay */
283         /* kill(parent, SIGUSR1); */
284         return parent;
285 }
286
287 int main(int argc, char *argv[])
288 {
289         char *tty = NULL;
290         char const *devprefix = "/dev/";
291         char *name = NULL;
292         char buf[IFNAMSIZ+1];
293         struct termios tios;
294         speed_t old_ispeed;
295         speed_t old_ospeed;
296
297         int opt;
298         int send_open = 0;
299         int send_close = 0;
300         int send_read_status_flags = 0;
301         char *speed = NULL;
302         char *uart_speed_str = NULL;
303         long int uart_speed = 0;
304         char *btr = NULL;
305         int run_as_daemon = 1;
306         pid_t parent_pid = 0;
307         char *pch;
308         int ldisc = LDISC_N_SLCAN;
309         int fd;
310
311         ttypath[0] = '\0';
312
313         while ((opt = getopt(argc, argv, "ocfs:S:b:?hF")) != -1) {
314                 switch (opt) {
315                 case 'o':
316                         send_open = 1;
317                         break;
318                 case 'c':
319                         send_close = 1;
320                         break;
321                 case 'f':
322                         send_read_status_flags = 1;
323                         break;
324                 case 's':
325                         speed = optarg;
326                         if (strlen(speed) > 1)
327                                 print_usage(argv[0]);
328                         break;
329                 case 'S':
330                         uart_speed_str = optarg;
331                         errno = 0;
332                         uart_speed = strtol(uart_speed_str, NULL, 10);
333                         if (errno)
334                                 print_usage(argv[0]);
335                         if (look_up_uart_speed(uart_speed) == -1) {
336                                 fprintf(stderr, "Unsupported UART speed (%lu)\n", uart_speed);
337                                 exit(EXIT_FAILURE);
338                         }
339                         break;
340                 case 'b':
341                         btr = optarg;
342                         if (strlen(btr) > 6)
343                                 print_usage(argv[0]);
344                         break;
345                 case 'F':
346                         run_as_daemon = 0;
347                         break;
348                 case 'h':
349                 case '?':
350                 default:
351                         print_usage(argv[0]);
352                         break;
353                 }
354         }
355
356         /* Initialize the logging interface */
357         openlog(DAEMON_NAME, LOG_PID, LOG_LOCAL5);
358
359         /* Parse serial device name and optional can interface name */
360         tty = argv[optind];
361         if (NULL == tty)
362                 print_usage(argv[0]);
363
364         name = argv[optind + 1];
365
366         /* Prepare the tty device name string */
367         pch = strstr(tty, devprefix);
368         if (pch == tty)
369                 print_usage(argv[0]);
370
371         snprintf(ttypath, TTYPATH_LENGTH, "%s%s", devprefix, tty);
372         syslog(LOG_INFO, "starting on TTY device %s", ttypath);
373
374         /* Daemonize */
375         if (run_as_daemon)
376                 parent_pid = daemonize("/var/lock/" DAEMON_NAME, tty, name);
377         else {
378                 /* Trap signals that we expect to receive */
379                 signal(SIGINT, child_handler);
380                 signal(SIGTERM, child_handler);
381         }
382
383         /* */
384         slcand_running = 1;
385
386         /* Now we are a daemon -- do the work for which we were paid */
387         fd = open(ttypath, O_RDWR | O_NONBLOCK | O_NOCTTY);
388         if (fd < 0) {
389                 syslog(LOG_NOTICE, "failed to open TTY device %s\n", ttypath);
390                 perror(ttypath);
391                 exit(EXIT_FAILURE);
392         }
393
394         /* Configure baud rate */
395         memset(&tios, 0, sizeof(struct termios));
396         if (tcgetattr(fd, &tios) < 0) {
397                 syslog(LOG_NOTICE, "failed to get attributes for TTY device %s: %s\n", ttypath, strerror(errno));
398                 exit(EXIT_FAILURE);
399         }
400
401         /* Get old values for later restore */
402         old_ispeed = cfgetispeed(&tios);
403         old_ospeed = cfgetospeed(&tios);
404
405         /* Baud Rate */
406         cfsetispeed(&tios, look_up_uart_speed(uart_speed));
407         cfsetospeed(&tios, look_up_uart_speed(uart_speed));
408
409         /* apply changes */
410         if (tcsetattr(fd, TCSADRAIN, &tios) < 0)
411                 syslog(LOG_NOTICE, "Cannot set attributes for device \"%s\": %s!\n", ttypath, strerror(errno));
412
413         if (speed) {
414                 sprintf(buf, "C\rS%s\r", speed);
415                 write(fd, buf, strlen(buf));
416         }
417
418         if (btr) {
419                 sprintf(buf, "C\rs%s\r", btr);
420                 write(fd, buf, strlen(buf));
421         }
422
423         if (send_read_status_flags) {
424                 sprintf(buf, "F\r");
425                 write(fd, buf, strlen(buf));
426         }
427
428         if (send_open) {
429                 sprintf(buf, "O\r");
430                 write(fd, buf, strlen(buf));
431         }
432
433         /* set slcan like discipline on given tty */
434         if (ioctl(fd, TIOCSETD, &ldisc) < 0) {
435                 perror("ioctl TIOCSETD");
436                 exit(1);
437         }
438         
439         /* retrieve the name of the created CAN netdevice */
440         if (ioctl(fd, SIOCGIFNAME, buf) < 0) {
441                 perror("ioctl SIOCGIFNAME");
442                 exit(1);
443         }
444
445         syslog(LOG_NOTICE, "attached TTY %s to netdevice %s\n", ttypath, buf);
446         
447         /* try to rename the created netdevice */
448         if (name) {
449                 struct ifreq ifr;
450                 int s = socket(PF_INET, SOCK_DGRAM, 0);
451
452                 if (s < 0)
453                         perror("socket for interface rename");
454                 else {
455                         strncpy(ifr.ifr_name, buf, IFNAMSIZ);
456                         strncpy(ifr.ifr_newname, name, IFNAMSIZ);
457
458                         if (ioctl(s, SIOCSIFNAME, &ifr) < 0) {
459                                 syslog(LOG_NOTICE, "netdevice %s rename to %s failed\n", buf, name);
460                                 perror("ioctl SIOCSIFNAME rename");
461                                 exit(1);
462                         } else
463                                 syslog(LOG_NOTICE, "netdevice %s renamed to %s\n", buf, name);
464
465                         close(s);
466                 }       
467         }
468         if (parent_pid > 0)
469                 kill(parent_pid, SIGUSR1);
470
471         /* The Big Loop */
472         while (slcand_running)
473                 sleep(1); /* wait 1 second */
474
475         /* Reset line discipline */
476         syslog(LOG_INFO, "stopping on TTY device %s", ttypath);
477         ldisc = N_TTY;
478         if (ioctl(fd, TIOCSETD, &ldisc) < 0) {
479                 perror("ioctl TIOCSETD");
480                 exit(EXIT_FAILURE);
481         }
482
483         if (send_close) {
484                 sprintf(buf, "C\r");
485                 write(fd, buf, strlen(buf));
486         }
487
488         /* Reset old rates */
489         cfsetispeed(&tios, old_ispeed);
490         cfsetospeed(&tios, old_ospeed);
491
492         /* apply changes */
493         if (tcsetattr(fd, TCSADRAIN, &tios) < 0)
494                 syslog(LOG_NOTICE, "Cannot set attributes for device \"%s\": %s!\n", ttypath, strerror(errno));
495
496         /* Remove pidfile */
497         if (run_as_daemon)
498                 unlink(pidfile);
499
500         /* Finish up */
501         syslog(LOG_NOTICE, "terminated on %s", ttypath);
502         closelog();
503         return exit_code;
504 }