#include <u.h>
#include <libc.h>
#include <bio.h>
#include <ndb.h>
#include <fcall.h>

enum
{
       Maxpath=        128,
};

typedef struct Endpoints Endpoints;
struct Endpoints
{
       char    *net;
       char    *lsys;
       char    *lserv;
       char    *rsys;
       char    *rserv;
};

void            xfer(int, int);
void            xfer9p(int, int);
Endpoints*      getendpoints(char*);
void            freeendpoints(Endpoints*);
char*           iptomac(char*, char*);
int             macok(char*);

void
usage(void)
{
       fprint(2, "usage: trampoline [-9] [-a addr] [-m netdir] addr\n");
       exits("usage");
}

void
main(int argc, char **argv)
{
       char *altaddr, *checkmac, *mac;
       int fd, fd0, fd1;
       void (*x)(int, int);
       Endpoints *ep;

       checkmac = nil;
       altaddr = nil;
       x = xfer;
       ARGBEGIN{
       case '9':
               x = xfer9p;
               break;
       case 'a':
               altaddr = EARGF(usage());
               break;
       case 'm':
               checkmac = EARGF(usage());
               break;
       default:
               usage();
       }ARGEND;

       if(argc != 1)
               usage();

       if(checkmac){
               ep = getendpoints(checkmac);
               mac = iptomac(ep->rsys, ep->net);
               if(!macok(mac)){
                       syslog(0, "trampoline", "badmac %s from %s!%s for %s!%s on %s",
                               mac, ep->rsys, ep->rserv, ep->lsys, ep->lserv, ep->net);
                       exits("bad mac");
               }
       }

       fd0 = 0;
       fd1 = 1;
       if(altaddr){
               fd0 = dial(altaddr, 0, 0, 0);
               if(fd0 < 0)
                       sysfatal("dial %s: %r", altaddr);
               fd1 = fd0;
       }
       fd = dial(argv[0], 0, 0, 0);
       if(fd < 0)
               sysfatal("dial %s: %r", argv[0]);

       rfork(RFNOTEG);
       switch(fork()){
       case -1:
               fprint(2, "%s: fork: %r\n", argv0);
               exits("dial");
       case 0:
               (*x)(fd0, fd);
               break;
       default:
               (*x)(fd, fd1);
               break;
       }
       postnote(PNGROUP, getpid(), "die yankee pig dog");
       exits(0);
}

void
xfer(int from, int to)
{
       char buf[12*1024];
       int n;

       while((n = read(from, buf, sizeof buf)) > 0)
               if(write(to, buf, n) < 0)
                       break;
}

void
xfer9p(int from, int to)
{
       uchar *buf;
       uint nbuf;
       int n;

       nbuf = 256;
       buf = malloc(nbuf);
       if(buf == nil)
               sysfatal("xfer: malloc %ud: %r", nbuf);

       for(;;){
               if(readn(from, buf, 4) != 4)
                       break;
               n = GBIT32(buf);
               if(n > nbuf){
                       nbuf = n+8192;
                       buf = realloc(buf, nbuf);
                       if(buf == nil)
                               sysfatal("xfer: realloc %ud: %r", nbuf);
               }
               if(readn(from, buf+4, n-4) != n-4)
                       break;
               if(write(to, buf, n) != n){
                       sysfatal("oops: %r");
                       break;
               }
       }
}

void
getendpoint(char *dir, char *file, char **sysp, char **servp)
{
       int fd, n;
       char buf[Maxpath];
       char *sys, *serv;

       sys = serv = 0;

       snprint(buf, sizeof buf, "%s/%s", dir, file);
       fd = open(buf, OREAD);
       if(fd >= 0){
               n = read(fd, buf, sizeof(buf)-1);
               if(n>0){
                       buf[n-1] = 0;
                       serv = strchr(buf, '!');
                       if(serv){
                               *serv++ = 0;
                               serv = strdup(serv);
                       }
                       sys = strdup(buf);
               }
               close(fd);
       }
       if(serv == 0)
               serv = strdup("unknown");
       if(sys == 0)
               sys = strdup("unknown");
       *servp = serv;
       *sysp = sys;
}

Endpoints *
getendpoints(char *dir)
{
       Endpoints *ep;
       char *p;

       ep = malloc(sizeof(*ep));
       ep->net = strdup(dir);
       p = strchr(ep->net+1, '/');
       if(p == nil){
               free(ep->net);
               ep->net = "/net";
       } else
               *p = 0;
       getendpoint(dir, "local", &ep->lsys, &ep->lserv);
       getendpoint(dir, "remote", &ep->rsys, &ep->rserv);
       return ep;
}

void
freeendpoints(Endpoints *ep)
{
       free(ep->lsys);
       free(ep->rsys);
       free(ep->lserv);
       free(ep->rserv);
       free(ep);
}

char*
iptomac(char *ip, char *net)
{
       char file[Maxpath];
       Biobuf *b;
       char *p;
       char *f[5];

       snprint(file, sizeof(file), "%s/arp", net);
       b = Bopen(file, OREAD);
       if(b == nil)
               return nil;
       while((p = Brdline(b, '\n')) != nil){
               p[Blinelen(b)-1] = 0;
               if(tokenize(p, f, nelem(f)) < 4)
                       continue;
               if(strcmp(f[1], "OK") == 0
               && strcmp(f[2], ip) == 0){
                       p = strdup(f[3]);
                       Bterm(b);
                       return p;
               }
       }
       Bterm(b);
       return nil;
}

int
macok(char *mac)
{
       char *p;

       if(mac == nil)
               return 0;
       free(p = csgetvalue("/net", "ether", mac, "trampok", nil));
       return !(p == nil);
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.