chiark / gitweb /
server/tun-slip.c: Fix signed/unsigned char mismatch.
[tripe] / server / tun-slip.c
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
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * TrIPE is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with TrIPE; if not, write to the Free Software Foundation,
24  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25  */
26
27 /*----- Header files ------------------------------------------------------*/
28
29 #define TUN_INTERNALS
30
31 #include "tripe.h"
32
33 /*----- Data structures ---------------------------------------------------*/
34
35 typedef struct slipif {
36   struct slipif *next;                  /* Next one in the list */
37   int ifd, ofd;                         /* File descriptors to talk on */
38   char *name;                           /* Interface name */
39   pid_t kid;                            /* Child process id */
40   unsigned f;                           /* Various flags */
41 #   define F_INUSE 1u                   /*   Interface is in use */
42 #   define F_DYNAMIC 2u                 /*   Interface found dynamically */
43 } slipif;
44
45 struct tunnel {
46   const tunnel_ops *ops;                /* Pointer to operations */
47   slipif *sl;                           /* My interface record */
48   sel_file f;                           /* Selector for SLIP tty */
49   struct peer *p;                       /* Pointer to my peer */
50   unsigned st;                          /* Current parser state */
51 #   define ST_ESC 1u                    /*   Last saw an escape character */
52 #   define ST_BAD 2u                    /*   This packet is malformed */
53 #   define ST_MASK 3u                   /*   Mask for the above bits */
54 #   define ST_EOF 4u                    /*   File descriptor reported EOF */
55 #   define ST_BROKEN 8u                 /*   Sending side is broken */
56   size_t n;                             /* Number of bytes used in buffer */
57   octet buf[PKBUFSZ];                   /* Buffer for incoming data */
58 };
59
60 /*----- Static variables --------------------------------------------------*/
61
62 static slipif *slipifs;                 /* List of available interfaces */
63 static const char *slipcmd;             /* Script to make new interfaces */
64
65 /*----- Main code ---------------------------------------------------------*/
66
67 /* --- @t_read@ --- *
68  *
69  * Arguments:   @int fd@ = file descriptor to read
70  *              @unsigned mode@ = what's happened
71  *              @void *v@ = pointer to tunnel block
72  *
73  * Returns:     ---
74  *
75  * Use:         Reads data from the tunnel.
76  */
77
78 static void t_read(int fd, unsigned mode, void *v)
79 {
80   tunnel *t = v;
81   ssize_t n;
82   const octet *p, *l, *ll;
83   octet *q;
84   unsigned st;
85   octet o;
86   buf b;
87
88   /* --- Read the input data --- */
89
90   n = read(fd, buf_t, sizeof(buf_t));
91   if (n < 0) {
92     if (errno == EINTR ||
93 #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN
94         errno == EWOULDBLOCK ||
95 #endif
96         errno == EAGAIN)
97       return;
98     a_warn("TUN", "%s", p_ifname(t->p), "slip",
99            "read-error", "?ERRNO", A_END);
100     return;
101   }
102   if (!n) {
103     a_warn("TUN", "%s", p_ifname(t->p), "slip", "eof", A_END);
104     t->st = (t->st & ~ST_MASK) | ST_EOF;
105     sel_rmfile(&t->f);
106     return;
107   }
108   IF_TRACING(T_TUNNEL, {
109     trace_block(T_PACKET, "tun-slip: SLIP-encapsulated data",
110                 buf_t, n);
111   })
112
113   /* --- Decapsulate the packet --- */
114
115   for (p = buf_t, l = p + n, st = t->st,
116        q = t->buf + t->n, ll = t->buf + sizeof(t->buf);
117        p < l;
118        p++) {
119     o = *p;
120     switch (o) {
121       case SL_END:
122         if (st & ST_BAD)
123           ;
124         else if (st & ST_ESC) {
125           a_warn("TUN", "%s", p_ifname(t->p), "slip", "escape-end", A_END);
126           st |= ST_BAD;
127         } else if (q == t->buf) {
128           T( trace(T_TUNNEL, "tun-slip: empty packet"); )
129         } else {
130           IF_TRACING(T_TUNNEL, {
131             trace(T_TUNNEL, "tun-slip: packet arrived");
132             trace_block(T_PACKET, "tun-slip: packet contents",
133                         t->buf, q - t->buf);
134           })
135           buf_init(&b, t->buf, q - t->buf);
136           p_tun(t->p, &b);
137         }
138         q = t->buf;
139         st &= ~ST_MASK;
140         break;
141       case SL_ESC:
142         if ((st & ST_ESC) && !(st & ST_BAD)) {
143           a_warn("TUN", "%s", p_ifname(t->p), "slip", "bad-escape", A_END);
144           st |= ST_BAD;
145         } else
146           st |= ST_ESC;
147         break;
148       case SL_ESCEND:
149         if (st & ST_ESC)
150           o = SL_END;
151         goto emit;
152       case SL_ESCESC:
153         if (st & ST_ESC)
154           o = SL_ESC;
155         goto emit;
156       default:
157         if ((st & ST_ESC) && !(st & ST_BAD)) {
158           a_warn("TUN", "%s", p_ifname(t->p), "slip", "bad-escape", A_END);
159           st |= ST_BAD;
160         }
161       emit:
162         if (!(st & ST_BAD)) {
163           if (q < ll)
164             *q++ = o;
165           else {
166             a_warn("TUN", "%s", p_ifname(t->p), "slip", "overflow", A_END);
167             st |= ST_BAD;
168           }
169         }
170         st &= ~ST_ESC;
171         break;
172     }
173   }
174
175   t->n = q - t->buf;
176   t->st = st;
177 }
178
179 /* --- @t_init@ --- *
180  *
181  * Arguments:   ---
182  *
183  * Returns:     ---
184  *
185  * Use:         Initializes the tunneling system.  Maybe this will require
186  *              opening file descriptors or something.
187  */
188
189 static void t_init(void)
190 {
191   char *p, *q;
192   dstr d = DSTR_INIT;
193   slipif *sl, **tail = &slipifs;
194   unsigned long uli, ulo;
195   size_t n;
196
197   if ((p = getenv("TRIPE_SLIPIF")) == 0)
198     return;
199
200   /* --- Build the list of available interfaces --- */
201
202   dstr_puts(&d, p);
203
204   p = d.buf;
205   for (;;) {
206     if (*p == '/' || *p == '.') {
207       slipcmd = p;
208       T( trace(T_TUNNEL, "tun-slip: declared slip command `%s'", slipcmd); )
209       break;
210     }
211     uli = strtoul(p, &q, 0);
212     if (uli > INT_MAX || q == p)
213       goto whine;
214     if (*q != ',')
215       ulo = uli;
216     else {
217       p = q + 1;
218       ulo = strtoul(p, &q, 0);
219       if (ulo > INT_MAX || q == p)
220         goto whine;
221     }
222     if (*q != '=' || (n = strcspn(q + 1, ":")) == 0)
223       goto whine;
224     sl = CREATE(slipif);
225     sl->next = 0;
226     sl->ifd = uli;
227     fdflags(sl->ifd, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
228     fdflags(sl->ofd, O_NONBLOCK, 0, FD_CLOEXEC, FD_CLOEXEC);
229     sl->ofd = ulo;
230     sl->name = xmalloc(n + 1);
231     sl->kid = -1;
232     sl->f = 0;
233     memcpy(sl->name, q + 1, n);
234     sl->name[n] = 0;
235     *tail = sl;
236     tail = &sl->next;
237     T( trace(T_TUNNEL, "tun-slip: declared slipif %d,%d=%s",
238              sl->ifd, sl->ofd, sl->name); )
239     p = q + n + 1;
240     if (!*p)
241       break;
242     p++;
243   }
244   return;
245
246 whine:
247   moan("bad slip interface list");
248 }
249
250 /* --- @t_broken@ --- *
251  *
252  * Arguments:   @tunnel *t@ = pointer to the tunnel
253  *
254  * Returns:     ---
255  *
256  * Use:         Marks the tunnel as broken and reports an error.
257  */
258
259 static void t_broken(tunnel *t)
260 {
261   if (errno == EINTR ||
262 #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN
263       errno == EWOULDBLOCK ||
264 #endif
265       errno == EAGAIN)
266     return;
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"); )
270   t->st |= ST_BROKEN;
271 }
272
273 /* --- @t_create@ --- *
274  *
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
278  *
279  * Returns:     A tunnel block if it worked, or null on failure.
280  *
281  * Use:         Initializes a new tunnel.
282  */
283
284 static tunnel *t_create(peer *p, int fd, char **ifn)
285 {
286   slipif *sl = 0;
287   int pin[2] = { -1, -1 }, pout[2] = { -1, -1 };
288   mdup_fd md[2];
289   pid_t kid = -1;
290   dstr d = DSTR_INIT;
291   unsigned char ch;
292   tunnel *t;
293   static const octet end[] = { SL_END, SL_END };
294
295   /* --- Try to find a spare static interface --- */
296
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); )
301       goto found;
302     }
303   }
304
305   /* --- If no dynamic interfaces are available, give up --- */
306
307   if (!slipcmd) {
308     a_warn("TUN", "-", "slip", "no-slip-interfaces", A_END);
309     goto fail;
310   }
311
312   /* --- Fork off a child process to create a dynamic SLIP interface --- */
313
314   if (pipe(pin) || pipe(pout)) {
315     a_warn("TUN", "-", "slip", "pipe-error", "?ERRNO", A_END);
316     goto fail;
317   }
318   if ((kid = fork()) < 0) {
319     a_warn("TUN", "-", "slip", "fork-error", "?ERRNO", A_END);
320     goto fail;
321   }
322   if (!kid) {
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;
326     mdup(md, 2);
327     execlp(slipcmd, slipcmd, p_name(p), (char *)0);
328     _exit(127);
329   }
330
331   /* --- Read the interface name --- */
332
333   sl = CREATE(slipif);
334   close(pin[0]); pin[0] = -1;
335   close(pout[1]); pout[1] = -1;
336   for (;;) {
337     errno = EIO;
338     if (read(pout[0], &ch, 1) != 1 || ch == SL_END) {
339       a_warn("TUN", "-", "slip", "read-ifname-failed", "?ERRNO", A_END);
340       goto fail;
341     }
342     if (ch == '\n')
343       break;
344     DPUTC(&d, (char)ch);
345   }
346   DPUTZ(&d);
347   sl->name = xstrdup(d.buf);
348   sl->ifd = pout[0];
349   sl->ofd = pin[1];
350   sl->kid = kid;
351   sl->next = 0;
352   sl->f = F_DYNAMIC;
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);
357
358   /* --- Set up the new tunnel --- */
359
360 found:
361   t = CREATE(tunnel);
362   t->ops = &tun_slip;
363   t->p = p;
364   t->sl = sl;
365   t->st = 0;
366   t->n = 0;
367   sl->f |= F_INUSE;
368   sel_initfile(&sel, &t->f, sl->ifd, SEL_READ, t_read, t);
369   sel_addfile(&t->f);
370   if (write(sl->ofd, end, sizeof(end)) < 0)
371     t_broken(t);
372   *ifn = xstrdup(sl->name);
373   dstr_destroy(&d);
374   return (t);
375
376   /* --- Tidy up after a failure --- */
377
378 fail:
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]);
382 #undef CLOSE
383   if (kid != -1) kill(kid, SIGTERM);
384   if (sl && (sl->f & F_DYNAMIC)) DESTROY(sl);
385   dstr_destroy(&d);
386   return (0);
387 }
388
389 /* --- @t_setifname@ --- *
390  *
391  * Arguments:   @tunnel *t@ = pointer to tunnel block
392  *              @const char *ifn@ = new interface name
393  *
394  * Returns:     ---
395  *
396  * Use:         Updates the interface name of a slip interface.
397  */
398
399 static void t_setifname(tunnel *t, const char *ifn)
400   { xfree(t->sl->name); t->sl->name = xstrdup(ifn); }
401
402 /* --- @t_inject@ --- *
403  *
404  * Arguments:   @tunnel *t@ = pointer to tunnel block
405  *              @buf *b@ = buffer to send
406  *
407  * Returns:     ---
408  *
409  * Use:         Injects a packet into the local network stack.
410  */
411
412 static void t_inject(tunnel *t, buf *b)
413 {
414   octet buf[PKBUFSZ * 2 + 2];
415   const octet *p, *l;
416   octet *q;
417
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));
421   })
422
423   if (t-> st & ST_BROKEN) {
424     T( trace(T_TUNNEL, "tun-slip: tunnel broken; discarding"); )
425     return;
426   }
427   q = buf;
428   *q++ = SL_END;
429   for (p = BBASE(b), l = BCUR(b); p < l; p++) {
430     switch (*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;
434     }
435   }
436   *q++ = SL_END;
437   IF_TRACING(T_TUNNEL, {
438     trace_block(T_PACKET, "tun-slip: SLIP-encapsulated contents",
439                 buf, q - buf);
440   })
441   if (write(t->sl->ofd, buf, q - buf) < 0)
442     t_broken(t);
443 }
444
445 /* --- @t_destroy@ --- *
446  *
447  * Arguments:   @tunnel *t@ = pointer to tunnel block
448  *
449  * Returns:     ---
450  *
451  * Use:         Destroys a tunnel.
452  */
453
454 static void t_destroy(tunnel *t)
455 {
456   slipif *sl = t->sl;
457
458   /* --- If it reported EOF, leave it out-of-action --- */
459
460   if (!(t->st & ST_EOF)) {
461     sel_rmfile(&t->f);
462     sl->f &= ~F_INUSE;
463   }
464   if (sl && (sl->f & F_DYNAMIC)) {
465     T( trace(T_TUNNEL, "tun-slip: releasing dynamic slipif %s", sl->name); )
466     close(sl->ofd);
467     close(sl->ifd);
468     kill(sl->kid, SIGTERM);
469     xfree(sl->name);
470     DESTROY(sl);
471   }
472   DESTROY(t);
473 }
474
475 const tunnel_ops tun_slip = {
476   "slip",
477   0,
478   t_init,
479   t_create,
480   t_setifname,
481   t_inject,
482   t_destroy
483 };
484
485 /*----- That's all, folks -------------------------------------------------*/