From 22fd0ebe07ae9f634cd5ab01dbc2e6506bc99b65 Mon Sep 17 00:00:00 2001 From: Ian Jackson Date: Sun, 15 May 2011 19:23:01 +0100 Subject: [PATCH] ipif: use tun, not slip; compiles, untested --- debian/changelog | 10 ++ ipif/service.c | 445 ++++++++++++++++++++++++----------------------- 2 files changed, 236 insertions(+), 219 deletions(-) diff --git a/debian/changelog b/debian/changelog index 47206f8..d72047f 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,3 +1,13 @@ +userv-utils (0.4~beta2) unstable; urgency=low + + ipif: + * Now uses tun, not slip. All modern Linux kernels have tun support, + and we weren't portable to non-Linux anyway. slattach has sometimes + been implicated in kernel problems. Interfaces are now called + "userv%d" (ie, userv0, userv1, etc.). + + -- + userv-utils (0.4~beta1) unstable; urgency=low git-daemon: diff --git a/ipif/service.c b/ipif/service.c index 08b0ed9..0a29f06 100644 --- a/ipif/service.c +++ b/ipif/service.c @@ -121,11 +121,23 @@ #include #include #include +#include +#include #include #include #include +#include +#include +#include + +#include +#include + +#include +#include + #define NARGS 4 #define MAXEXROUTES 50 #define ATXTLEN 16 @@ -155,53 +167,11 @@ static struct pplace { } *cpplace; -static int slpipe[2], ptmaster, undoslattach; -static const char *ifname; -static const char *ptyname; - -#define NPIDS 4 - -static union { - struct { pid_t sl, cout, cin, task; } byname; - pid_t bynumber[NPIDS]; -} pids; -sigset_t emptyset, fullset; +static int tunfd; +static char *ifname; -static int cleantask(void) { - pid_t pid; - - pid= fork(); - if (!pid) return 1; - if (pid == (pid_t)-1) - perror("userv-ipif: fork for undo slattach failed - cannot clean up properly"); - return 0; -} - static void terminate(int estatus) { - int i, status; - pid_t pid; - - for (i=0; isa_handler= handler; - sa->sa_flags= 0; - for (signalp=signals; (sig=*signalp); signalp++) { - r= sigaction(sig, sa, 0); if (r) sysfatal("uncatch signal"); - } - sa->sa_flags= chldflags; - r= sigaction(SIGCHLD, sa, 0); if (r) sysfatal("uncatch children"); -} - -static void infork(void) { - struct sigaction sa; - - memset(&pids,0,sizeof(pids)); - sigemptyset(&sa.sa_mask); - setsignals(SIG_DFL,&sa,0); - setsigmask(&emptyset); - undoslattach= 0; -} - -static pid_t makesubproc(void (*entry)(void)) { - pid_t pid; - - pid= fork(); if (pid == (pid_t)-1) sysfatal("fork for subprocess"); - if (pid) return pid; - - infork(); - entry(); - abort(); -} - -static int task(void) { - pid_t pid; +static int task(const char *desc) { + pid_t pid, pidr; + int status; pid= fork(); if (pid == (pid_t)-1) sysfatal("fork for task"); - if (!pid) { infork(); return 1; } - - pids.byname.task= pid; - while (pids.byname.task) sigsuspend(&emptyset); - return 0; -} - -static void mdup2(int fd1, int fd2, const char *what) { - int r; + if (!pid) return 1; for (;;) { - r= dup2(fd1,fd2); if (r==fd2) return; - if (r!=-1) fatal("dup2 in %s gave wrong answer %d instead of %d",what,r,fd2); - if (errno != EINTR) sysfatal("dup2 failed in %s",what); + pidr= waitpid(pid,&status,WNOHANG); + if (pidr!=(pid_t)-1) break; + if (errno==EINTR) continue; + sysfatal("waitpid for task"); } -} + assert(pidr==pid); -static void sl_entry(void) { - mdup2(slpipe[1],1,"slattach child"); - execlp("slattach", "slattach", "-v", "-L", "-p",proto, ptyname, (char*)0); - sysfatal("cannot exec slattach"); -} - -static void cin_entry(void) { - mdup2(ptmaster,1,"cat input child"); - execlp("cat", "cat", (char*)0); - sysfatal("cannot exec cat input"); -} - -static void cout_entry(void) { - mdup2(ptmaster,0,"cat output child"); - execlp("cat", "cat", (char*)0); - sysfatal("cannot exec cat output"); -} - -static void sighandler(int signum) { - pid_t pid; - int estatus, status; - const char *taskfail; - - estatus= 4; - - if (signum == SIGCHLD) { - for (;;) { - pid= waitpid(-1,&status,WNOHANG); - if (!pid || pid == (pid_t)-1) return; - - if (pid == pids.byname.task) { - pids.byname.task= 0; - if (!status) return; - taskfail= "task"; - } else if (pid == pids.byname.cin) { - pids.byname.cin= 0; - if (status) { - taskfail= "input cat"; - } else { - taskfail= 0; - estatus= 0; - } - } else if (pid == pids.byname.cout) { - pids.byname.cout= 0; - taskfail= "output cat"; - } else if (pid == pids.byname.sl) { - pids.byname.sl= 0; - taskfail= "slattach"; - } else { - continue; - } - break; - } - if (taskfail) { - if (WIFEXITED(status)) { - fprintf(stderr, - "userv-ipif service: %s unexpectedly exited with exit status %d\n", - taskfail, WEXITSTATUS(status)); - } else if (WIFSIGNALED(status)) { - fprintf(stderr, - "userv-ipif service: %s unexpectedly killed by signal %s%s\n", - taskfail, strsignal(WTERMSIG(status)), - WCOREDUMP(status) ? " (core dumped)" : ""); - } else { - fprintf(stderr, "userv-ipif service: %s unexpectedly terminated" - " with unknown status code %d\n", taskfail, status); - } - } - } else { + if (WIFEXITED(status)) { + fprintf(stderr, + "userv-ipif service: %s unexpectedly exited with exit status %d\n", + desc, WEXITSTATUS(status)); + } else if (WIFSIGNALED(status)) { fprintf(stderr, - "userv-ipif service: received signal %d, terminating\n", - signum); + "userv-ipif service: %s unexpectedly killed by signal %s%s\n", + desc, strsignal(WTERMSIG(status)), + WCOREDUMP(status) ? " (core dumped)" : ""); + } else { + fprintf(stderr, "userv-ipif service: %s unexpectedly terminated" + " with unknown status code %d\n", desc, status); } - terminate(estatus); + return 0; } -static void startup(void) { +static void createif(void) { + static const char ifnamepat[]= "userv%d"; + struct ifreq ifr; int r; - struct sigaction sa; - - sigfillset(&fullset); - sigemptyset(&emptyset); - - ptmaster= getpt(); if (ptmaster==-1) sysfatal("allocate pty master"); - r= grantpt(ptmaster); if (r) sysfatal("grab/grant pty slave"); - ptyname= ptsname(ptmaster); if (!ptyname) sysfatal("get pty slave name"); - r= chmod(ptyname,0600); if (r) sysfatal("chmod pty slave"); - r= unlockpt(ptmaster); if (r) sysfatal("unlock pty"); - - sigfillset(&sa.sa_mask); - setsignals(sighandler,&sa,SA_NOCLDSTOP); - setsigmask(&fullset); -} -static void startslattach(void) { - static char ifnbuf[200]; + memset(&ifr,0,sizeof(ifr)); + ifr.ifr_flags= IFF_TUN | IFF_NO_PI; - FILE *piper; - int r, l, k; + assert(sizeof(ifr.ifr_name) >= sizeof(ifnamepat)); + strcpy(ifr.ifr_name, ifnamepat); - r= pipe(slpipe); if (r) sysfatal("create pipe"); - piper= fdopen(slpipe[0],"r"); if (!piper) sysfatal("fdopen pipe"); + tunfd= open("/dev/net/tun", O_RDWR); + if (!tunfd) sysfatal("open /dev/net/tun"); - undoslattach= 1; - pids.byname.sl= makesubproc(sl_entry); + r= fcntl(tunfd, F_GETFD); + if (r==-1) sysfatal("fcntl(tunfd,F_GETFD)"); + r= fcntl(tunfd, F_SETFD, r|FD_CLOEXEC); + if (r==-1) sysfatal("fcntl(tunfd,F_SETFD,|FD_CLOEXEC)"); - close(slpipe[1]); - setsigmask(&emptyset); - if (!fgets(ifnbuf,sizeof(ifnbuf),piper)) { - if (ferror(piper)) sysfatal("cannot read ifname from slattach"); - else fatal("cannot read ifname from slattach"); - } - setsigmask(&fullset); - l= strlen(ifnbuf); - if (l<=0 || ifnbuf[l-1] != '\n') fatal("slattach gave strange output `%s'",ifnbuf); - ifnbuf[l-1]= 0; - for (k=l; k>0 && ifnbuf[k-1]!=' '; k--); - ifname= ifnbuf+k; + r= ioctl(tunfd, TUNSETIFF, (void*)&ifr); + if (r) sysfatal("ioctl TUNSETIFF"); + + /* ifr.ifr_name might not be null-terminated. crazy abi. */ + ifname= malloc(sizeof(ifr.ifr_name)+1); + if (!ifname) sysfatal("malloc for interface name"); + memcpy(ifname, ifr.ifr_name, sizeof(ifr.ifr_name)); + ifname[sizeof(ifr.ifr_name)]= 0; } static void netconfigure(void) { char mtutxt[100]; int i; - if (task()) { + if (task("ifconfig")) { sprintf(mtutxt,"%lu",mtu); execlp("ifconfig", "ifconfig", ifname, localtxt, @@ -854,7 +702,7 @@ static void netconfigure(void) { } for (i=0; i=ip_end) break; + uint8_t c= *ip++; + if (c==SLIP_END) { + rx_packet(output_buf, op-output_buf); + op= output_buf; + eaten= ip - input_buf; + continue; + } + if (c==SLIP_ESC) { + if (ip>=ip_end) { /* rescan this when there's more */ ip--; break; } + c= *ip++; + if (c==SLIP_ESC_END) c=SLIP_END; + else if (c==SLIP_ESC_ESC) c=SLIP_ESC; + else fatal("unexpected byte 0%o after SLIP_ESC",c); + } + if (op == output_buf+mtu) + fatal("SLIP packet exceeds mtu"); + *op++= c; + } + + output_len= op - output_buf; + scanned= ip - input_buf; + + input_waiting -= eaten; + memmove(input_buf, input_buf+eaten, input_waiting); + scanned -= eaten; +} + +static void tx_packet(uint8_t *output_buf, const uint8_t *ip, int inlen) { + /* output_buf is passed as a parameter since it's in copydata's stack frame */ + assert(!output_waiting); + uint8_t *op= output_buf; + + *op++= SLIP_END; + while (inlen-- >0) { + uint8_t c= *ip++; + if (c==SLIP_END) { *op++= SLIP_ESC; *op++= SLIP_ESC_END; } + else if (c==SLIP_ESC) { *op++= SLIP_ESC; *op++= SLIP_ESC_ESC; } + else *op++= c; } - pids.byname.cout= makesubproc(cout_entry); + output_waiting= op - output_buf; +} + +static void copydata(void) __attribute__((noreturn)); +static void copydata(void) { + uint8_t output_buf[mtu*2+2]; + uint8_t input_buf[mtu*2+2]; + uint8_t rx_packet_buf[mtu]; + + int r, i; - for (;;) sigsuspend(&emptyset); + struct pollfd polls[3]; + memset(polls, 0, sizeof(polls)); + + polls[0].fd= 0; polls[0].events= POLLIN; + polls[1].fd= 1; + polls[2].fd= tunfd; + + /* We don't do flow control on input packets; instead, we just throw + * away ones which the kernel doesn't accept. So we always poll for + * those. + * + * Output packets we buffer, so we poll only as appropriate for those. + */ + + for (;;) { + if (output_waiting) { + r= write(1, output_buf, output_waiting); + if (r<0) { + if (errno==EINTR) continue; + if (errno!=EAGAIN) + sysfatal("error writing SLIP output (packets being received)"); + } else { + assert(r>0); + output_waiting -= r; + memmove(output_buf, output_buf+r, output_waiting); + } + } + if (output_waiting) { + polls[1].events |= POLLOUT; + polls[2].events &= ~POLLIN; + } else { + polls[1].events &= ~POLLOUT; + polls[2].events |= POLLIN; + } + r= poll(polls,3,-1); + + if (r<0) { + if (errno==EINTR) continue; + sysfatal("poll() failed"); + } + assert(r>0); /* we used an infinite timeout */ + + for (i=0; i0) { + input_waiting += r; + assert(r < sizeof(input_buf)); + more_rx_data(input_buf, rx_packet_buf); + } else if (r==0) { + terminate(0); + } else { + if (!(errno==EINTR || errno==EAGAIN)) + sysfatal("error reading input SLIP data (packets to transmit)"); + } + } + + /* We handle what would be (polls[1].events & POLLOUT) above, + * unconditionally. That eliminates the need to poll in the usual case */ + + if (polls[2].events & POLLIN) { + uint8_t packet_buf[mtu]; + r= read(tunfd, packet_buf, mtu); + if (r>0) { + tx_packet(output_buf, packet_buf, r); + } else { + assert(r<0); + if (!(errno==EAGAIN || errno==EWOULDBLOCK)) + sysfatal("error reading packet (being transmitted) from tun"); + } + } + } } int main(int argc, const char *const *argv) { @@ -883,8 +888,10 @@ int main(int argc, const char *const *argv) { checkpermit(); if (!proto) dumpdebug(); - startup(); - startslattach(); + createif(); netconfigure(); + setnonblock(tunfd); + setnonblock(0); + setnonblock(1); copydata(); } -- 2.30.2