Document how to use Open vSwitch as a replacement for the Linux bridge.
[openvswitch] / extras / ezio / tty.c
1 /* Copyright (c) 2008, 2009 Nicira Networks, Inc.
2  *
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15
16 #include <config.h>
17 #include "extras/ezio/tty.h"
18 #include <errno.h>
19 #include <fcntl.h>
20 #include <pwd.h>
21 #include <signal.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <stropts.h>
25 #include <sys/ioctl.h>
26 #include <sys/stat.h>
27 #include <unistd.h>
28 #include "fatal-signal.h"
29 #include "socket-util.h"
30 #include "util.h"
31
32 #define THIS_MODULE VLM_tty
33 #include "vlog.h"
34
35 /* Get major() and minor() macros. */
36 #if MAJOR_IN_MKDEV
37 #  include <sys/mkdev.h>
38 #elif MAJOR_IN_SYSMACROS
39 #  include <sys/sysmacros.h>
40 #else
41 #  include <sys/types.h>
42 #  ifndef major
43 #    define major(dev) (((dev) >> 8) & 0xff)
44 #    define minor(dev) ((dev) & 0xff)
45 #  endif
46 #endif
47
48 static int
49 fcntl_lock(int fd)
50 {
51     struct flock l;
52     memset(&l, 0, sizeof l);
53     l.l_type = F_WRLCK;
54     l.l_whence = SEEK_SET;
55     l.l_start = 0;
56     l.l_len = 0;
57     return fcntl(fd, F_SETLK, &l) == -1 ? errno : 0;
58 }
59
60 static int
61 remove_lockfile(const char *name)
62 {
63     char buffer[BUFSIZ];
64     ssize_t n;
65     pid_t pid;
66     int fd;
67
68     /* Remove existing lockfile. */
69     fd = open(name, O_RDWR);
70     if (fd < 0) {
71         if (errno == ENOENT) {
72             return 0;
73         } else {
74             VLOG_ERR("%s: open: %s", name, strerror(errno));
75             return errno;
76         }
77     }
78
79     /* Read lockfile. */
80     n = read(fd, buffer, sizeof buffer - 1);
81     if (n < 0) {
82         int error = errno;
83         VLOG_ERR("%s: read: %s", name, strerror(error));
84         close(fd);
85         return error;
86     }
87     buffer[n] = '\0';
88     if (n == 4 && memchr(buffer, '\0', n)) {
89         int32_t x;
90         memcpy(&x, buffer, sizeof x);
91         pid = x;
92     } else if (n >= 0) {
93         pid = strtol(buffer, NULL, 10);
94     }
95     if (pid <= 0) {
96         close(fd);
97         VLOG_WARN("%s: format not recognized, treating as locked.", name);
98         return EACCES;
99     }
100
101     /* Is lockfile fresh? */
102     if (strstr(buffer, "fcntl")) {
103         int retval = fcntl_lock(fd);
104         if (retval) {
105             close(fd);
106             VLOG_ERR("%s: device is locked (via fcntl): %s",
107                      name, strerror(retval));
108             return retval;
109         } else {
110             VLOG_WARN("%s: removing stale lockfile (checked via fcntl)", name);
111         }
112     } else {
113         if (!(kill(pid, 0) < 0 && errno == ESRCH)) {
114             close(fd);
115             VLOG_ERR("%s: device is locked (without fcntl)", name);
116             return EACCES;
117         } else {
118             VLOG_WARN("%s: removing stale lockfile (without fcntl)", name);
119         }
120     }
121     close(fd);
122
123     /* Remove stale lockfile. */
124     if (unlink(name)) {
125         VLOG_ERR("%s: unlink: %s", name, strerror(errno));
126         return errno;
127     }
128     return 0;
129 }
130
131 static int
132 create_lockfile(const char *name)
133 {
134     const char *username;
135     char buffer[BUFSIZ];
136     struct passwd *pwd;
137     mode_t old_umask;
138     uid_t uid;
139     int fd;
140
141     /* Create file. */
142     old_umask = umask(022);
143     fd = open(name, O_WRONLY | O_CREAT | O_EXCL, 0666);
144     if (fd < 0) {
145         int error = errno;
146         VLOG_ERR("%s: create: %s", name, strerror(error));
147         umask(old_umask);
148         return error;
149     }
150     umask(old_umask);
151
152     /* Lock file. */
153     if (fcntl_lock(fd)) {
154         int error = errno;
155         close(fd);
156         VLOG_ERR("%s: cannot lock: %s", name, strerror(error));
157         return error;
158     }
159
160     /* Write to file. */
161     uid = getuid();
162     pwd = getpwuid(uid);
163     username = pwd ? pwd->pw_name : "unknown";
164     snprintf(buffer, sizeof buffer, "%10ld %s %.20s fcntl\n",
165              (long int) getpid(), program_name, username);
166     if (write(fd, buffer, strlen(buffer)) != strlen(buffer)) {
167         int error = errno;
168         VLOG_ERR("%s: write: %s", name, strerror(error));
169         close(fd);
170         unlink(name);
171         return error;
172     }
173
174     /* We intentionally do not close 'fd', to avoid releasing the fcntl lock.
175      * The asssumption here is that we never unlock a tty. */
176     fatal_signal_add_file_to_unlink(name);
177
178     return 0;
179 }
180
181 static int
182 do_lock(char *name)
183 {
184     int retval = remove_lockfile(name);
185     if (!retval) {
186         retval = create_lockfile(name);
187     }
188     free(name);
189     return retval;
190 }
191
192 int
193 tty_lock(const char *dev_name)
194 {
195     struct stat s;
196     char *name;
197     int retval;
198
199     /* Check that the lockfile directory exists. */
200     if (stat(TTY_LOCK_DIR, &s)) {
201         VLOG_ERR("%s: stat: %s", TTY_LOCK_DIR, strerror(errno));
202         return errno;
203     }
204
205     /* First lock by device number. */
206     if (stat(dev_name, &s)) {
207         VLOG_ERR("%s: stat: %s", dev_name, strerror(errno));
208         return errno;
209     }
210     retval = do_lock(xasprintf("%s/LK.%03d.%03d.%03d", TTY_LOCK_DIR,
211                                major(s.st_dev),
212                                major(s.st_rdev), minor(s.st_rdev)));
213     if (retval) {
214         return retval;
215     }
216
217     /* Then lock by device name. */
218     if (!strncmp(dev_name, "/dev/", 5)) {
219         char *cp;
220
221         name = xasprintf("%s/%s", TTY_LOCK_DIR, dev_name + 5);
222         for (cp = name + strlen(dev_name) + 1; *cp; cp++) {
223             if (*cp == '/') {
224                 *cp = '_';
225             }
226         }
227     } else {
228         char *slash = strrchr(dev_name, '/');
229         name = xasprintf ("%s/%s", TTY_LOCK_DIR, slash ? slash + 1 : dev_name);
230     }
231     return do_lock(name);
232 }
233
234 struct saved_termios {
235     int fd;
236     struct termios tios;
237 };
238
239 static void
240 restore_termios(void *s_)
241 {
242     struct saved_termios *s = s_;
243     tcsetattr(s->fd, TCSAFLUSH, &s->tios);
244 }
245
246 int
247 tty_set_raw_mode(int fd, speed_t speed)
248 {
249     if (isatty(fd)) {
250         struct termios tios;
251         struct saved_termios *s;
252
253         if (tcgetattr(fd, &tios) < 0) {
254             return errno;
255         }
256
257         s = xmalloc(sizeof *s);
258         s->fd = dup(fd);
259         if (s->fd < 0) {
260             int error = errno;
261             VLOG_WARN("dup failed: %s", strerror(error));
262             free(s);
263             return errno;
264         }
265         s->tios = tios;
266         fatal_signal_add_hook(restore_termios, s, true);
267
268         tios.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP
269                           | INLCR | IGNCR | ICRNL | IXON);
270         tios.c_oflag &= ~OPOST;
271         tios.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
272         tios.c_cflag &= ~(CSIZE | PARENB);
273         tios.c_cflag |= CS8;
274         if (speed != B0) {
275             cfsetispeed(&tios, speed);
276             cfsetospeed(&tios, speed);
277         }
278         if (tcsetattr(fd, TCSAFLUSH, &tios) < 0) {
279             return errno;
280         }
281     }
282     return set_nonblocking(fd);
283 }
284
285 int
286 tty_open_master_pty(void)
287 {
288     int retval;
289     int fd;
290
291     fd = posix_openpt(O_RDWR | O_NOCTTY);
292     if (fd < 0) {
293         int error = errno;
294         VLOG_WARN("posix_openpt failed: %s", strerror(error));
295         close(fd);
296         return -error;
297     }
298
299     if (grantpt(fd) < 0) {
300         int error = errno;
301         VLOG_WARN("grantpt failed: %s", strerror(error));
302         close(fd);
303         return -error;
304     }
305
306     if (unlockpt(fd) < 0) {
307         int error = errno;
308         VLOG_WARN("unlockpt failed: %s", strerror(error));
309         close(fd);
310         return -error;
311     }
312
313     retval = set_nonblocking(fd);
314     if (retval) {
315         VLOG_WARN("set_nonblocking failed: %s", strerror(retval));
316         close(fd);
317         return retval;
318     }
319
320     return fd;
321 }
322
323 int
324 tty_fork_child(int master_fd, char *argv[])
325 {
326     int retval = fork();
327     if (!retval) {
328         char *slave_name;
329         int slave_fd;
330         int fd;
331
332         /* Running in child process. */
333         fatal_signal_fork();
334
335         /* Open pty slave as controlling terminal. */
336         setsid();
337         slave_name = ptsname(master_fd);
338         if (slave_name == NULL) {
339             ovs_fatal(errno, "ptsname");
340         }
341         slave_fd = open(slave_name, O_RDWR);
342         if (isastream(slave_fd)
343             && (ioctl(slave_fd, I_PUSH, "ptem") < 0
344                 || ioctl(slave_fd, I_PUSH, "ldterm") < 0)) {
345             ovs_fatal(errno, "STREAMS ioctl");
346         }
347
348         /* Make pty slave stdin, stdout. */
349         if (dup2(slave_fd, STDIN_FILENO) < 0
350             || dup2(slave_fd, STDOUT_FILENO) < 0
351             || dup2(slave_fd, STDERR_FILENO) < 0) {
352             ovs_fatal(errno, "dup2");
353         }
354
355         /* Close other file descriptors. */
356         for (fd = 3; fd < 20; fd++) {
357             close(fd);
358         }
359
360         /* Set terminal type. */
361         setenv("TERM", "ezio3", true);
362
363         /* Invoke subprocess. */
364         execvp(argv[0], argv);
365         ovs_fatal(errno, "execvp");
366     } else if (retval > 0) {
367         /* Running in parent process. */
368         return 0;
369     } else {
370         /* Fork failed. */
371         VLOG_WARN("fork failed: %s", strerror(errno));
372         return errno;
373     }
374 }
375
376 int
377 tty_set_window_size(int fd UNUSED, int rows UNUSED, int columns UNUSED)
378 {
379 #ifdef TIOCGWINSZ
380     struct winsize win;
381     win.ws_row = rows;
382     win.ws_col = columns;
383     win.ws_xpixel = 0;
384     win.ws_ypixel = 0;
385     if (ioctl(fd, TIOCSWINSZ, &win) == -1) {
386         return errno;
387     }
388 #else
389 #error
390 #endif
391     return 0;
392 }