3 * Tunnel packets via SLIP
5 * (c) 2005 Straylight/Edgeware
8 /*----- Licensing notice --------------------------------------------------*
10 * This file is part of Trivial IP Encryption (TrIPE).
12 * TrIPE is free software: you can redistribute it and/or modify it under
13 * the terms of the GNU General Public License as published by the Free
14 * Software Foundation; either version 3 of the License, or (at your
15 * option) any later version.
17 * TrIPE is distributed in the hope that it will be useful, but WITHOUT
18 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
19 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
22 * You should have received a copy of the GNU General Public License
23 * along with TrIPE. If not, see <https://www.gnu.org/licenses/>.
26 /*----- Header files ------------------------------------------------------*/
32 /*----- Data structures ---------------------------------------------------*/
34 typedef struct slipif {
35 struct slipif *next; /* Next one in the list */
36 int ifd, ofd; /* File descriptors to talk on */
37 char *name; /* Interface name */
38 pid_t kid; /* Child process id */
39 unsigned f; /* Various flags */
40 # define F_INUSE 1u /* Interface is in use */
41 # define F_DYNAMIC 2u /* Interface found dynamically */
45 const tunnel_ops *ops; /* Pointer to operations */
46 slipif *sl; /* My interface record */
47 sel_file f; /* Selector for SLIP tty */
48 struct peer *p; /* Pointer to my peer */
49 unsigned st; /* Current parser state */
50 # define ST_ESC 1u /* Last saw an escape character */
51 # define ST_BAD 2u /* This packet is malformed */
52 # define ST_MASK 3u /* Mask for the above bits */
53 # define ST_EOF 4u /* File descriptor reported EOF */
54 # define ST_BROKEN 8u /* Sending side is broken */
55 size_t n; /* Number of bytes used in buffer */
56 octet buf[PKBUFSZ]; /* Buffer for incoming data */
59 /*----- Static variables --------------------------------------------------*/
61 static slipif *slipifs; /* List of available interfaces */
62 static const char *slipcmd; /* Script to make new interfaces */
64 /*----- Main code ---------------------------------------------------------*/
68 * Arguments: @int fd@ = file descriptor to read
69 * @unsigned mode@ = what's happened
70 * @void *v@ = pointer to tunnel block
74 * Use: Reads data from the tunnel.
77 static void t_read(int fd, unsigned mode, void *v)
81 const octet *p, *l, *ll;
87 /* --- Read the input data --- */
89 n = read(fd, buf_t, sizeof(buf_t));
92 #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN
93 errno == EWOULDBLOCK ||
97 a_warn("TUN", "%s", p_ifname(t->p), "slip",
98 "read-error", "?ERRNO", A_END);
102 a_warn("TUN", "%s", p_ifname(t->p), "slip", "eof", A_END);
103 t->st = (t->st & ~ST_MASK) | ST_EOF;
107 IF_TRACING(T_TUNNEL, {
108 trace_block(T_PACKET, "tun-slip: SLIP-encapsulated data",
112 /* --- Decapsulate the packet --- */
114 for (p = buf_t, l = p + n, st = t->st,
115 q = t->buf + t->n, ll = t->buf + sizeof(t->buf);
123 else if (st & ST_ESC) {
124 a_warn("TUN", "%s", p_ifname(t->p), "slip", "escape-end", A_END);
126 } else if (q == t->buf) {
127 T( trace(T_TUNNEL, "tun-slip: empty packet"); )
129 IF_TRACING(T_TUNNEL, {
130 trace(T_TUNNEL, "tun-slip: packet arrived");
131 trace_block(T_PACKET, "tun-slip: packet contents",
134 buf_init(&b, t->buf, q - t->buf);
141 if ((st & ST_ESC) && !(st & ST_BAD)) {
142 a_warn("TUN", "%s", p_ifname(t->p), "slip", "bad-escape", A_END);
156 if ((st & ST_ESC) && !(st & ST_BAD)) {
157 a_warn("TUN", "%s", p_ifname(t->p), "slip", "bad-escape", A_END);
161 if (!(st & ST_BAD)) {
165 a_warn("TUN", "%s", p_ifname(t->p), "slip", "overflow", A_END);
178 /* --- @t_init@ --- *
182 * Returns: Zero on success, @-1@ on failure.
184 * Use: Initializes the tunneling system. Maybe this will require
185 * opening file descriptors or something.
188 static int t_init(void)
192 slipif *sl, **tail = &slipifs;
193 unsigned long uli, ulo;
196 if ((p = getenv("TRIPE_SLIPIF")) == 0)
199 /* --- Build the list of available interfaces --- */
205 if (*p == '/' || *p == '.') {
207 T( trace(T_TUNNEL, "tun-slip: declared slip command `%s'", slipcmd); )
210 uli = strtoul(p, &q, 0);
211 if (uli > INT_MAX || q == p)
217 ulo = strtoul(p, &q, 0);
218 if (ulo > INT_MAX || q == p)
221 if (*q != '=' || (n = strcspn(q + 1, ":")) == 0)
226 fdflags(sl->ifd, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
227 fdflags(sl->ofd, O_NONBLOCK, 0, FD_CLOEXEC, FD_CLOEXEC);
229 sl->name = xmalloc(n + 1);
232 memcpy(sl->name, q + 1, n);
236 T( trace(T_TUNNEL, "tun-slip: declared slipif %d,%d=%s",
237 sl->ifd, sl->ofd, sl->name); )
246 a_warn("TUN", "-", "slip", "bad-interface-list", A_END);
250 /* --- @t_broken@ --- *
252 * Arguments: @tunnel *t@ = pointer to the tunnel
256 * Use: Marks the tunnel as broken and reports an error.
259 static void t_broken(tunnel *t)
261 if (errno == EINTR ||
262 #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN
263 errno == EWOULDBLOCK ||
267 a_warn("TUN", "%s", p_ifname(t->p), "slip",
268 "write-error", "?ERRNO", A_END);
269 T( trace(T_TUNNEL, "tun-slip: marking tunnel broken"); )
273 /* --- @t_create@ --- *
275 * Arguments: @peer *p@ = pointer to peer block
276 * @int fd@ = file descriptor of tunnel device (unused)
277 * @char **ifn@ = where to put the interface name
279 * Returns: A tunnel block if it worked, or null on failure.
281 * Use: Initializes a new tunnel.
284 static tunnel *t_create(peer *p, int fd, char **ifn)
287 int pin[2] = { -1, -1 }, pout[2] = { -1, -1 };
293 static const octet end[] = { SL_END, SL_END };
295 /* --- Try to find a spare static interface --- */
297 for (sl = slipifs; sl; sl = sl->next) {
298 if (!(sl->f & F_INUSE)) {
299 T( trace(T_TUNNEL, "tun-slip: %s using static slipif %s",
300 p_name(p), sl->name); )
305 /* --- If no dynamic interfaces are available, give up --- */
308 a_warn("TUN", "-", "slip", "no-slip-interfaces", A_END);
312 /* --- Fork off a child process to create a dynamic SLIP interface --- */
314 if (pipe(pin) || pipe(pout)) {
315 a_warn("TUN", "-", "slip", "pipe-error", "?ERRNO", A_END);
318 if ((kid = fork()) < 0) {
319 a_warn("TUN", "-", "slip", "fork-error", "?ERRNO", A_END);
323 close(pin[1]); close(pout[0]);
324 md[0].cur = pin[0]; md[0].want = STDIN_FILENO;
325 md[1].cur = pout[1]; md[1].want = STDOUT_FILENO;
327 execlp(slipcmd, slipcmd, p_name(p), (char *)0);
331 /* --- Read the interface name --- */
334 close(pin[0]); pin[0] = -1;
335 close(pout[1]); pout[1] = -1;
338 if (read(pout[0], &ch, 1) != 1 || ch == SL_END) {
339 a_warn("TUN", "-", "slip", "read-ifname-failed", "?ERRNO", A_END);
347 sl->name = xstrdup(d.buf);
353 T( trace(T_TUNNEL, "tun-slip: %s using dynamic slipif %s",
354 p_name(p), sl->name); )
355 fdflags(pout[0], O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
356 fdflags(pin[1], O_NONBLOCK, 0, FD_CLOEXEC, FD_CLOEXEC);
358 /* --- Set up the new tunnel --- */
368 sel_initfile(&sel, &t->f, sl->ifd, SEL_READ, t_read, t);
370 if (write(sl->ofd, end, sizeof(end)) < 0)
372 *ifn = xstrdup(sl->name);
376 /* --- Tidy up after a failure --- */
379 #define CLOSE(fd) do if (fd != -1) close(fd); while (0)
380 CLOSE(pin[0]); CLOSE(pout[0]);
381 CLOSE(pin[1]); CLOSE(pout[1]);
383 if (kid != -1) kill(kid, SIGTERM);
384 if (sl && (sl->f & F_DYNAMIC)) DESTROY(sl);
389 /* --- @t_setifname@ --- *
391 * Arguments: @tunnel *t@ = pointer to tunnel block
392 * @const char *ifn@ = new interface name
396 * Use: Updates the interface name of a slip interface.
399 static void t_setifname(tunnel *t, const char *ifn)
400 { xfree(t->sl->name); t->sl->name = xstrdup(ifn); }
402 /* --- @t_inject@ --- *
404 * Arguments: @tunnel *t@ = pointer to tunnel block
405 * @buf *b@ = buffer to send
409 * Use: Injects a packet into the local network stack.
412 static void t_inject(tunnel *t, buf *b)
414 octet buf[PKBUFSZ * 2 + 2];
418 IF_TRACING(T_TUNNEL, {
419 trace(T_TUNNEL, "tun-slip: inject decrypted packet");
420 trace_block(T_PACKET, "tun-slip: packet contents", BBASE(b), BLEN(b));
423 if (t-> st & ST_BROKEN) {
424 T( trace(T_TUNNEL, "tun-slip: tunnel broken; discarding"); )
429 for (p = BBASE(b), l = BCUR(b); p < l; p++) {
431 case SL_END: *q++ = SL_ESC; *q++ = SL_ESCEND; break;
432 case SL_ESC: *q++ = SL_ESC; *q++ = SL_ESCESC; break;
433 default: *q++ = *p; break;
437 IF_TRACING(T_TUNNEL, {
438 trace_block(T_PACKET, "tun-slip: SLIP-encapsulated contents",
441 if (write(t->sl->ofd, buf, q - buf) < 0)
445 /* --- @t_destroy@ --- *
447 * Arguments: @tunnel *t@ = pointer to tunnel block
451 * Use: Destroys a tunnel.
454 static void t_destroy(tunnel *t)
458 /* --- If it reported EOF, leave it out-of-action --- */
460 if (!(t->st & ST_EOF)) {
464 if (sl && (sl->f & F_DYNAMIC)) {
465 T( trace(T_TUNNEL, "tun-slip: releasing dynamic slipif %s", sl->name); )
468 kill(sl->kid, SIGTERM);
475 const tunnel_ops tun_slip = {
485 /*----- That's all, folks -------------------------------------------------*/