| 1 | /* -*-c-*- |
| 2 | * |
| 3 | * Tunnel packets via SLIP |
| 4 | * |
| 5 | * (c) 2005 Straylight/Edgeware |
| 6 | */ |
| 7 | |
| 8 | /*----- Licensing notice --------------------------------------------------* |
| 9 | * |
| 10 | * This file is part of Trivial IP Encryption (TrIPE). |
| 11 | * |
| 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. |
| 16 | * |
| 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 |
| 20 | * for more details. |
| 21 | * |
| 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/>. |
| 24 | */ |
| 25 | |
| 26 | /*----- Header files ------------------------------------------------------*/ |
| 27 | |
| 28 | #define TUN_INTERNALS |
| 29 | |
| 30 | #include "tripe.h" |
| 31 | |
| 32 | /*----- Data structures ---------------------------------------------------*/ |
| 33 | |
| 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 */ |
| 42 | } slipif; |
| 43 | |
| 44 | struct tunnel { |
| 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 */ |
| 57 | }; |
| 58 | |
| 59 | /*----- Static variables --------------------------------------------------*/ |
| 60 | |
| 61 | static slipif *slipifs; /* List of available interfaces */ |
| 62 | static const char *slipcmd; /* Script to make new interfaces */ |
| 63 | |
| 64 | /*----- Main code ---------------------------------------------------------*/ |
| 65 | |
| 66 | /* --- @t_read@ --- * |
| 67 | * |
| 68 | * Arguments: @int fd@ = file descriptor to read |
| 69 | * @unsigned mode@ = what's happened |
| 70 | * @void *v@ = pointer to tunnel block |
| 71 | * |
| 72 | * Returns: --- |
| 73 | * |
| 74 | * Use: Reads data from the tunnel. |
| 75 | */ |
| 76 | |
| 77 | static void t_read(int fd, unsigned mode, void *v) |
| 78 | { |
| 79 | tunnel *t = v; |
| 80 | ssize_t n; |
| 81 | const octet *p, *l, *ll; |
| 82 | octet *q; |
| 83 | unsigned st; |
| 84 | octet o; |
| 85 | buf b; |
| 86 | |
| 87 | /* --- Read the input data --- */ |
| 88 | |
| 89 | n = read(fd, buf_t, sizeof(buf_t)); |
| 90 | if (n < 0) { |
| 91 | if (errno == EINTR || |
| 92 | #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN |
| 93 | errno == EWOULDBLOCK || |
| 94 | #endif |
| 95 | errno == EAGAIN) |
| 96 | return; |
| 97 | a_warn("TUN", "%s", p_ifname(t->p), "slip", |
| 98 | "read-error", "?ERRNO", A_END); |
| 99 | return; |
| 100 | } |
| 101 | if (!n) { |
| 102 | a_warn("TUN", "%s", p_ifname(t->p), "slip", "eof", A_END); |
| 103 | t->st = (t->st & ~ST_MASK) | ST_EOF; |
| 104 | sel_rmfile(&t->f); |
| 105 | return; |
| 106 | } |
| 107 | IF_TRACING(T_TUNNEL, { |
| 108 | trace_block(T_PACKET, "tun-slip: SLIP-encapsulated data", |
| 109 | buf_t, n); |
| 110 | }) |
| 111 | |
| 112 | /* --- Decapsulate the packet --- */ |
| 113 | |
| 114 | for (p = buf_t, l = p + n, st = t->st, |
| 115 | q = t->buf + t->n, ll = t->buf + sizeof(t->buf); |
| 116 | p < l; |
| 117 | p++) { |
| 118 | o = *p; |
| 119 | switch (o) { |
| 120 | case SL_END: |
| 121 | if (st & ST_BAD) |
| 122 | ; |
| 123 | else if (st & ST_ESC) { |
| 124 | a_warn("TUN", "%s", p_ifname(t->p), "slip", "escape-end", A_END); |
| 125 | st |= ST_BAD; |
| 126 | } else if (q == t->buf) { |
| 127 | T( trace(T_TUNNEL, "tun-slip: empty packet"); ) |
| 128 | } else { |
| 129 | IF_TRACING(T_TUNNEL, { |
| 130 | trace(T_TUNNEL, "tun-slip: packet arrived"); |
| 131 | trace_block(T_PACKET, "tun-slip: packet contents", |
| 132 | t->buf, q - t->buf); |
| 133 | }) |
| 134 | buf_init(&b, t->buf, q - t->buf); |
| 135 | p_tun(t->p, &b); |
| 136 | } |
| 137 | q = t->buf; |
| 138 | st &= ~ST_MASK; |
| 139 | break; |
| 140 | case SL_ESC: |
| 141 | if ((st & ST_ESC) && !(st & ST_BAD)) { |
| 142 | a_warn("TUN", "%s", p_ifname(t->p), "slip", "bad-escape", A_END); |
| 143 | st |= ST_BAD; |
| 144 | } else |
| 145 | st |= ST_ESC; |
| 146 | break; |
| 147 | case SL_ESCEND: |
| 148 | if (st & ST_ESC) |
| 149 | o = SL_END; |
| 150 | goto emit; |
| 151 | case SL_ESCESC: |
| 152 | if (st & ST_ESC) |
| 153 | o = SL_ESC; |
| 154 | goto emit; |
| 155 | default: |
| 156 | if ((st & ST_ESC) && !(st & ST_BAD)) { |
| 157 | a_warn("TUN", "%s", p_ifname(t->p), "slip", "bad-escape", A_END); |
| 158 | st |= ST_BAD; |
| 159 | } |
| 160 | emit: |
| 161 | if (!(st & ST_BAD)) { |
| 162 | if (q < ll) |
| 163 | *q++ = o; |
| 164 | else { |
| 165 | a_warn("TUN", "%s", p_ifname(t->p), "slip", "overflow", A_END); |
| 166 | st |= ST_BAD; |
| 167 | } |
| 168 | } |
| 169 | st &= ~ST_ESC; |
| 170 | break; |
| 171 | } |
| 172 | } |
| 173 | |
| 174 | t->n = q - t->buf; |
| 175 | t->st = st; |
| 176 | } |
| 177 | |
| 178 | /* --- @t_init@ --- * |
| 179 | * |
| 180 | * Arguments: --- |
| 181 | * |
| 182 | * Returns: --- |
| 183 | * |
| 184 | * Use: Initializes the tunneling system. Maybe this will require |
| 185 | * opening file descriptors or something. |
| 186 | */ |
| 187 | |
| 188 | static void t_init(void) |
| 189 | { |
| 190 | char *p, *q; |
| 191 | dstr d = DSTR_INIT; |
| 192 | slipif *sl, **tail = &slipifs; |
| 193 | unsigned long uli, ulo; |
| 194 | size_t n; |
| 195 | |
| 196 | if ((p = getenv("TRIPE_SLIPIF")) == 0) |
| 197 | return; |
| 198 | |
| 199 | /* --- Build the list of available interfaces --- */ |
| 200 | |
| 201 | dstr_puts(&d, p); |
| 202 | |
| 203 | p = d.buf; |
| 204 | for (;;) { |
| 205 | if (*p == '/' || *p == '.') { |
| 206 | slipcmd = p; |
| 207 | T( trace(T_TUNNEL, "tun-slip: declared slip command `%s'", slipcmd); ) |
| 208 | break; |
| 209 | } |
| 210 | uli = strtoul(p, &q, 0); |
| 211 | if (uli > INT_MAX || q == p) |
| 212 | goto whine; |
| 213 | if (*q != ',') |
| 214 | ulo = uli; |
| 215 | else { |
| 216 | p = q + 1; |
| 217 | ulo = strtoul(p, &q, 0); |
| 218 | if (ulo > INT_MAX || q == p) |
| 219 | goto whine; |
| 220 | } |
| 221 | if (*q != '=' || (n = strcspn(q + 1, ":")) == 0) |
| 222 | goto whine; |
| 223 | sl = CREATE(slipif); |
| 224 | sl->next = 0; |
| 225 | sl->ifd = uli; |
| 226 | fdflags(sl->ifd, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC); |
| 227 | fdflags(sl->ofd, O_NONBLOCK, 0, FD_CLOEXEC, FD_CLOEXEC); |
| 228 | sl->ofd = ulo; |
| 229 | sl->name = xmalloc(n + 1); |
| 230 | sl->kid = -1; |
| 231 | sl->f = 0; |
| 232 | memcpy(sl->name, q + 1, n); |
| 233 | sl->name[n] = 0; |
| 234 | *tail = sl; |
| 235 | tail = &sl->next; |
| 236 | T( trace(T_TUNNEL, "tun-slip: declared slipif %d,%d=%s", |
| 237 | sl->ifd, sl->ofd, sl->name); ) |
| 238 | p = q + n + 1; |
| 239 | if (!*p) |
| 240 | break; |
| 241 | p++; |
| 242 | } |
| 243 | return; |
| 244 | |
| 245 | whine: |
| 246 | a_warn("TUN", "-", "slip", "bad-interface-list", A_END); |
| 247 | } |
| 248 | |
| 249 | /* --- @t_broken@ --- * |
| 250 | * |
| 251 | * Arguments: @tunnel *t@ = pointer to the tunnel |
| 252 | * |
| 253 | * Returns: --- |
| 254 | * |
| 255 | * Use: Marks the tunnel as broken and reports an error. |
| 256 | */ |
| 257 | |
| 258 | static void t_broken(tunnel *t) |
| 259 | { |
| 260 | if (errno == EINTR || |
| 261 | #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN |
| 262 | errno == EWOULDBLOCK || |
| 263 | #endif |
| 264 | errno == EAGAIN) |
| 265 | return; |
| 266 | a_warn("TUN", "%s", p_ifname(t->p), "slip", |
| 267 | "write-error", "?ERRNO", A_END); |
| 268 | T( trace(T_TUNNEL, "tun-slip: marking tunnel broken"); ) |
| 269 | t->st |= ST_BROKEN; |
| 270 | } |
| 271 | |
| 272 | /* --- @t_create@ --- * |
| 273 | * |
| 274 | * Arguments: @peer *p@ = pointer to peer block |
| 275 | * @int fd@ = file descriptor of tunnel device (unused) |
| 276 | * @char **ifn@ = where to put the interface name |
| 277 | * |
| 278 | * Returns: A tunnel block if it worked, or null on failure. |
| 279 | * |
| 280 | * Use: Initializes a new tunnel. |
| 281 | */ |
| 282 | |
| 283 | static tunnel *t_create(peer *p, int fd, char **ifn) |
| 284 | { |
| 285 | slipif *sl = 0; |
| 286 | int pin[2] = { -1, -1 }, pout[2] = { -1, -1 }; |
| 287 | mdup_fd md[2]; |
| 288 | pid_t kid = -1; |
| 289 | dstr d = DSTR_INIT; |
| 290 | unsigned char ch; |
| 291 | tunnel *t; |
| 292 | static const octet end[] = { SL_END, SL_END }; |
| 293 | |
| 294 | /* --- Try to find a spare static interface --- */ |
| 295 | |
| 296 | for (sl = slipifs; sl; sl = sl->next) { |
| 297 | if (!(sl->f & F_INUSE)) { |
| 298 | T( trace(T_TUNNEL, "tun-slip: %s using static slipif %s", |
| 299 | p_name(p), sl->name); ) |
| 300 | goto found; |
| 301 | } |
| 302 | } |
| 303 | |
| 304 | /* --- If no dynamic interfaces are available, give up --- */ |
| 305 | |
| 306 | if (!slipcmd) { |
| 307 | a_warn("TUN", "-", "slip", "no-slip-interfaces", A_END); |
| 308 | goto fail; |
| 309 | } |
| 310 | |
| 311 | /* --- Fork off a child process to create a dynamic SLIP interface --- */ |
| 312 | |
| 313 | if (pipe(pin) || pipe(pout)) { |
| 314 | a_warn("TUN", "-", "slip", "pipe-error", "?ERRNO", A_END); |
| 315 | goto fail; |
| 316 | } |
| 317 | if ((kid = fork()) < 0) { |
| 318 | a_warn("TUN", "-", "slip", "fork-error", "?ERRNO", A_END); |
| 319 | goto fail; |
| 320 | } |
| 321 | if (!kid) { |
| 322 | close(pin[1]); close(pout[0]); |
| 323 | md[0].cur = pin[0]; md[0].want = STDIN_FILENO; |
| 324 | md[1].cur = pout[1]; md[1].want = STDOUT_FILENO; |
| 325 | mdup(md, 2); |
| 326 | execlp(slipcmd, slipcmd, p_name(p), (char *)0); |
| 327 | _exit(127); |
| 328 | } |
| 329 | |
| 330 | /* --- Read the interface name --- */ |
| 331 | |
| 332 | sl = CREATE(slipif); |
| 333 | close(pin[0]); pin[0] = -1; |
| 334 | close(pout[1]); pout[1] = -1; |
| 335 | for (;;) { |
| 336 | errno = EIO; |
| 337 | if (read(pout[0], &ch, 1) != 1 || ch == SL_END) { |
| 338 | a_warn("TUN", "-", "slip", "read-ifname-failed", "?ERRNO", A_END); |
| 339 | goto fail; |
| 340 | } |
| 341 | if (ch == '\n') |
| 342 | break; |
| 343 | DPUTC(&d, (char)ch); |
| 344 | } |
| 345 | DPUTZ(&d); |
| 346 | sl->name = xstrdup(d.buf); |
| 347 | sl->ifd = pout[0]; |
| 348 | sl->ofd = pin[1]; |
| 349 | sl->kid = kid; |
| 350 | sl->next = 0; |
| 351 | sl->f = F_DYNAMIC; |
| 352 | T( trace(T_TUNNEL, "tun-slip: %s using dynamic slipif %s", |
| 353 | p_name(p), sl->name); ) |
| 354 | fdflags(pout[0], O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC); |
| 355 | fdflags(pin[1], O_NONBLOCK, 0, FD_CLOEXEC, FD_CLOEXEC); |
| 356 | |
| 357 | /* --- Set up the new tunnel --- */ |
| 358 | |
| 359 | found: |
| 360 | t = CREATE(tunnel); |
| 361 | t->ops = &tun_slip; |
| 362 | t->p = p; |
| 363 | t->sl = sl; |
| 364 | t->st = 0; |
| 365 | t->n = 0; |
| 366 | sl->f |= F_INUSE; |
| 367 | sel_initfile(&sel, &t->f, sl->ifd, SEL_READ, t_read, t); |
| 368 | sel_addfile(&t->f); |
| 369 | if (write(sl->ofd, end, sizeof(end)) < 0) |
| 370 | t_broken(t); |
| 371 | *ifn = xstrdup(sl->name); |
| 372 | dstr_destroy(&d); |
| 373 | return (t); |
| 374 | |
| 375 | /* --- Tidy up after a failure --- */ |
| 376 | |
| 377 | fail: |
| 378 | #define CLOSE(fd) do if (fd != -1) close(fd); while (0) |
| 379 | CLOSE(pin[0]); CLOSE(pout[0]); |
| 380 | CLOSE(pin[1]); CLOSE(pout[1]); |
| 381 | #undef CLOSE |
| 382 | if (kid != -1) kill(kid, SIGTERM); |
| 383 | if (sl && (sl->f & F_DYNAMIC)) DESTROY(sl); |
| 384 | dstr_destroy(&d); |
| 385 | return (0); |
| 386 | } |
| 387 | |
| 388 | /* --- @t_setifname@ --- * |
| 389 | * |
| 390 | * Arguments: @tunnel *t@ = pointer to tunnel block |
| 391 | * @const char *ifn@ = new interface name |
| 392 | * |
| 393 | * Returns: --- |
| 394 | * |
| 395 | * Use: Updates the interface name of a slip interface. |
| 396 | */ |
| 397 | |
| 398 | static void t_setifname(tunnel *t, const char *ifn) |
| 399 | { xfree(t->sl->name); t->sl->name = xstrdup(ifn); } |
| 400 | |
| 401 | /* --- @t_inject@ --- * |
| 402 | * |
| 403 | * Arguments: @tunnel *t@ = pointer to tunnel block |
| 404 | * @buf *b@ = buffer to send |
| 405 | * |
| 406 | * Returns: --- |
| 407 | * |
| 408 | * Use: Injects a packet into the local network stack. |
| 409 | */ |
| 410 | |
| 411 | static void t_inject(tunnel *t, buf *b) |
| 412 | { |
| 413 | octet buf[PKBUFSZ * 2 + 2]; |
| 414 | const octet *p, *l; |
| 415 | octet *q; |
| 416 | |
| 417 | IF_TRACING(T_TUNNEL, { |
| 418 | trace(T_TUNNEL, "tun-slip: inject decrypted packet"); |
| 419 | trace_block(T_PACKET, "tun-slip: packet contents", BBASE(b), BLEN(b)); |
| 420 | }) |
| 421 | |
| 422 | if (t-> st & ST_BROKEN) { |
| 423 | T( trace(T_TUNNEL, "tun-slip: tunnel broken; discarding"); ) |
| 424 | return; |
| 425 | } |
| 426 | q = buf; |
| 427 | *q++ = SL_END; |
| 428 | for (p = BBASE(b), l = BCUR(b); p < l; p++) { |
| 429 | switch (*p) { |
| 430 | case SL_END: *q++ = SL_ESC; *q++ = SL_ESCEND; break; |
| 431 | case SL_ESC: *q++ = SL_ESC; *q++ = SL_ESCESC; break; |
| 432 | default: *q++ = *p; break; |
| 433 | } |
| 434 | } |
| 435 | *q++ = SL_END; |
| 436 | IF_TRACING(T_TUNNEL, { |
| 437 | trace_block(T_PACKET, "tun-slip: SLIP-encapsulated contents", |
| 438 | buf, q - buf); |
| 439 | }) |
| 440 | if (write(t->sl->ofd, buf, q - buf) < 0) |
| 441 | t_broken(t); |
| 442 | } |
| 443 | |
| 444 | /* --- @t_destroy@ --- * |
| 445 | * |
| 446 | * Arguments: @tunnel *t@ = pointer to tunnel block |
| 447 | * |
| 448 | * Returns: --- |
| 449 | * |
| 450 | * Use: Destroys a tunnel. |
| 451 | */ |
| 452 | |
| 453 | static void t_destroy(tunnel *t) |
| 454 | { |
| 455 | slipif *sl = t->sl; |
| 456 | |
| 457 | /* --- If it reported EOF, leave it out-of-action --- */ |
| 458 | |
| 459 | if (!(t->st & ST_EOF)) { |
| 460 | sel_rmfile(&t->f); |
| 461 | sl->f &= ~F_INUSE; |
| 462 | } |
| 463 | if (sl && (sl->f & F_DYNAMIC)) { |
| 464 | T( trace(T_TUNNEL, "tun-slip: releasing dynamic slipif %s", sl->name); ) |
| 465 | close(sl->ofd); |
| 466 | close(sl->ifd); |
| 467 | kill(sl->kid, SIGTERM); |
| 468 | xfree(sl->name); |
| 469 | DESTROY(sl); |
| 470 | } |
| 471 | DESTROY(t); |
| 472 | } |
| 473 | |
| 474 | const tunnel_ops tun_slip = { |
| 475 | "slip", |
| 476 | 0, |
| 477 | t_init, |
| 478 | t_create, |
| 479 | t_setifname, |
| 480 | t_inject, |
| 481 | t_destroy |
| 482 | }; |
| 483 | |
| 484 | /*----- That's all, folks -------------------------------------------------*/ |