usr.bin/vknet/vknet.c

   1 /*
   2  * Copyright (c) 2008 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@backplane.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  * $DragonFly: src/usr.bin/vknet/vknet.c,v 1.1 2008/05/27 23:26:38 dillon Exp $
  35  */
  36 /*
  37  * vknet [-r timeout[:retries]] [-C] [-b local_bridge] [-B remote_bridge] local remote
  38  * vknet -S [-b local_bridge] local     (server mode)
  39  *
  40  * Connect a SOCK_SEQPACKET socket or TUN device on the local host with
  41  * a SOCK_SEQPACKET socket or TUN device on the remote host through a SSH
  42  * connection.  When a TUN device is specified it may be optionally bridged.
  43  *
  44  * This program expects packetized reads and writes on the local and remote
  45  * sides and will re-block them over the SSH stream.
  46  */
  47
  48 #include "vknet.h"
  49
  50 static void vknet_blastaway(ioinfo_t ios, ioinfo_t iod);
  51 static void *vknet_stream(void *arg);
  52 static void vknet_connect(ioinfo_t ios,
  53                           const char *localSide, const char *localBridge);
  54 static void vknet_execssh(int fdin, int fdout, int compressOpt,
  55                           const char *remoteSide, const char *remoteBridge);
  56 static void usage(void);
  57
  58 pthread_mutex_t MasterLock;
  59
  60 int
  61 main(int ac, char **av)
  62 {
  63         int compressOpt = 0;
  64         int remoteOpt = 0;
  65         const char *localBridge = NULL;
  66         const char *remoteBridge = NULL;
  67         const char *localSide;
  68         const char *remoteSide;
  69         char *ptr;
  70         int c;
  71         int retriesOpt = -1;
  72         int timeoutOpt = -1;
  73         struct ioinfo ios;
  74         struct ioinfo iod;
  75
  76         while ((c = getopt(ac, av, "b:B:r:CS")) != -1) {
  77                 switch (c) {
  78                 case 'b':
  79                         localBridge = optarg;
  80                         break;
  81                 case 'B':
  82                         remoteBridge = optarg;
  83                         break;
  84                 case 'r':
  85                         timeoutOpt = strtol(optarg, &ptr, 0);
  86                         if (ptr && *ptr == ':')
  87                                 retriesOpt = strtol(ptr + 1, NULL, 0);
  88                         break;
  89                 case 'S':
  90                         remoteOpt = 1;
  91                         break;
  92                 case 'C':
  93                         compressOpt = 1;
  94                         break;
  95                 default:
  96                         usage();
  97                 }
  98         }
  99         av += optind;
 100         ac -= optind;
 101
 102         /*
 103          * Local and remote arguments.
 104          */
 105         if (remoteOpt) {
 106                 if (ac != 1)
 107                         usage();
 108                 localSide = av[0];
 109                 remoteSide = NULL;
 110         } else {
 111                 if (ac != 2)
 112                         usage();
 113                 localSide = av[0];
 114                 remoteSide = av[1];
 115         }
 116
 117         pthread_mutex_init(&MasterLock, NULL);
 118
 119 retry:
 120         /*
 121          * Setup connections
 122          */
 123         vknet_connect(&ios, localSide, localBridge);
 124         if (remoteOpt) {
 125                 iod.fdin = 0;
 126                 iod.fdout = 1;
 127         } else {
 128                 int fds[2];
 129
 130                 if (pipe(fds) < 0) {
 131                         perror("pipe");
 132                         exit(1);
 133                 }
 134                 vknet_execssh(fds[1], fds[1], compressOpt,
 135                               remoteSide, remoteBridge);
 136                 close(fds[1]);
 137                 iod.fdin = fds[0];
 138                 iod.fdout = fds[0];
 139         }
 140
 141         /*
 142          * Blast away, timeout/retry on failure
 143          */
 144         vknet_blastaway(&ios, &iod);
 145
 146         /*
 147          * Handle timeout/retries
 148          */
 149         if (timeoutOpt >= 0 && retriesOpt != 0) {
 150                 printf("timeout %d retries %d\n", timeoutOpt, retriesOpt);
 151                 if (timeoutOpt > 0)
 152                         sleep(timeoutOpt);
 153                 if (retriesOpt > 0)
 154                         --retriesOpt;
 155                 goto retry;
 156         }
 157         exit(0);
 158 }
 159
 160 static void
 161 vknet_blastaway(ioinfo_t ios, ioinfo_t iod)
 162 {
 163         struct streaminfo stream1;
 164         struct streaminfo stream2;
 165
 166         pthread_mutex_lock(&MasterLock);
 167         stream1.fdin = ios->fdin;
 168         stream1.fdout = iod->fdout;
 169         stream1.flags = REBLOCK_OUT;
 170         stream1.other = &stream2;
 171         stream2.fdin = iod->fdin;
 172         stream2.fdout = ios->fdout;
 173         stream2.flags = REBLOCK_IN;
 174         stream2.other = &stream1;
 175         pthread_create(&stream1.thread, NULL, vknet_stream, &stream1);
 176         pthread_create(&stream2.thread, NULL, vknet_stream, &stream2);
 177         pthread_mutex_unlock(&MasterLock);
 178         pthread_join(stream1.thread, NULL);
 179         pthread_join(stream2.thread, NULL);
 180 }
 181
 182 /*
 183  * Transfer packets between two descriptors
 184  */
 185 static
 186 void *
 187 vknet_stream(void *arg)
 188 {
 189         streaminfo_t stream = arg;
 190         struct blkhead head;
 191         u_int8_t *pkt;
 192         int bytes;
 193         int n;
 194         int r;
 195
 196         /*
 197          * Synchronize with master thread, then loop
 198          */
 199         pthread_mutex_lock(&MasterLock);
 200         pthread_mutex_unlock(&MasterLock);
 201
 202         pkt = malloc(MAXPKT);
 203
 204         for (;;) {
 205                 /*
 206                  * Input side
 207                  */
 208                 if (stream->flags & REBLOCK_IN) {
 209                         bytes = sizeof(head);
 210                         for (n = 0; n < bytes; n += r) {
 211                                 r = read(stream->fdin, (char *)&head + n,
 212                                          bytes - n);
 213                                 if (r <= 0)
 214                                         break;
 215                         }
 216                         if (n != bytes)
 217                                 break;
 218                         if (le32toh(head.magic) != MAGIC)
 219                                 break;
 220                         bytes = le32toh(head.bytes);
 221                         if (bytes <= 0 || bytes > MAXPKT)
 222                                 break;
 223                         for (n = 0; n < bytes; n += r) {
 224                                 r = read(stream->fdin, pkt + n, bytes - n);
 225                                 if (r <= 0)
 226                                         break;
 227                         }
 228                         if (n != bytes)
 229                                 break;
 230                 } else {
 231                         bytes = read(stream->fdin, pkt, MAXPKT);
 232                         if (bytes <= 0)
 233                                 break;
 234                 }
 235
 236                 /*
 237                  * Output side
 238                  */
 239                 if (stream->flags & REBLOCK_OUT) {
 240                         head.magic = htole32(MAGIC);
 241                         head.bytes = htole32(bytes);
 242                         if (write(stream->fdout, &head, sizeof(head)) != sizeof(head))
 243                                 break;
 244                         if (write(stream->fdout, pkt, bytes) != bytes)
 245                                 break;
 246                 } else {
 247                         if (write(stream->fdout, pkt, bytes) != bytes)
 248                                 break;
 249                 }
 250         }
 251         free(pkt);
 252         close(stream->fdin);
 253         close(stream->fdout);
 254         pthread_cancel(stream->other->thread);
 255         pthread_exit(NULL);
 256 }
 257
 258 /*
 259  * vknet_connect() - Connect to local side, optinally find or bridge the tap
 260  *                   interface.
 261  */
 262 static void
 263 vknet_connect(ioinfo_t io, const char *localSide, const char *localBridge)
 264 {
 265         struct ifreq ifr;
 266         struct ifaliasreq ifra;
 267         char *buf = NULL;
 268         int tap_fd;
 269         int tap_unit;
 270         int i;
 271         int s;
 272         int flags;
 273
 274         tap_unit = -1;
 275         tap_fd = -1;
 276
 277         if (strcmp(localSide, "auto") == 0) {
 278                 for (i = 0; ; ++i) {
 279                         asprintf(&buf, "/dev/tap%d", i);
 280                         tap_fd = open(buf, O_RDWR | O_NONBLOCK);
 281                         free(buf);
 282                         if (tap_fd >= 0 || errno == ENOENT) {
 283                                 tap_unit = i;
 284                                 break;
 285                         }
 286                 }
 287         } else if (strncmp(localSide, "tap", 3) == 0) {
 288                 asprintf(&buf, "/dev/%s", localSide);
 289                 tap_fd = open(buf, O_RDWR | O_NONBLOCK);
 290                 tap_unit = strtol(localSide + 3, NULL, 10);
 291                 free(buf);
 292         } else if ((tap_fd = open(localSide, O_RDWR | O_NONBLOCK)) >= 0) {
 293                 const char *ptr = localSide + strlen(localSide);
 294                 while (ptr > localSide && ptr[-1] >= '0' && ptr[-1] <= '9')
 295                         --ptr;
 296                 tap_unit = strtol(ptr, NULL, 10);
 297         } else {
 298                 struct sockaddr_un sunx;
 299                 int len;
 300
 301                 snprintf(sunx.sun_path, sizeof(sunx.sun_path), "%s", localSide);
 302                 len = offsetof(struct sockaddr_un,
 303                                sun_path[strlen(sunx.sun_path)]);
 304                 ++len;  /* include nul */
 305                 sunx.sun_family = AF_UNIX;
 306                 sunx.sun_len = len;
 307
 308                 tap_fd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
 309                 if (tap_fd >= 0)         {
 310                         if (connect(tap_fd, (void *)&sunx, len) < 0) {
 311                                 close(tap_fd);
 312                                 tap_fd = -1;
 313                         }
 314                 }
 315         }
 316
 317         if (tap_fd < 0) {
 318                 err(1, "Unable to connect to %s", localSide);
 319                 /* NOT REACHED */
 320         }
 321
 322         fcntl(tap_fd, F_SETFL, 0);
 323         io->fdin = tap_fd;
 324         io->fdout = tap_fd;
 325
 326         /*
 327          * If this isn't a TAP device we are done.
 328          */
 329         if (tap_unit < 0)
 330                 return;
 331
 332         /*
 333          * Bring up the TAP interface
 334          */
 335         bzero(&ifr, sizeof(ifr));
 336         bzero(&ifra, sizeof(ifra));
 337         snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "tap%d", tap_unit);
 338         snprintf(ifra.ifra_name, sizeof(ifra.ifra_name), "tap%d", tap_unit);
 339
 340         s = socket(AF_INET, SOCK_DGRAM, 0);
 341
 342 #if 0
 343         /*
 344          * Set the interface address if in Secure mode.
 345          */
 346         if (SecureOpt) {
 347                 struct sockaddr_in *in;
 348
 349                 in = (void *)&ifra.ifra_addr;
 350                 in->sin_family = AF_INET;
 351                 in->sin_len = sizeof(ifra.ifra_addr);
 352                 in->sin_addr = NetAddress;
 353                 in = (void *)&ifra.ifra_mask;
 354                 in->sin_family = AF_INET;
 355                 in->sin_len = sizeof(ifra.ifra_mask);
 356                 in->sin_addr = NetMask;
 357                 if (ioctl(s, SIOCAIFADDR, &ifra) < 0) {
 358                         perror("Unable to set address on tap interface");
 359                         exit(1);
 360                 }
 361         }
 362 #endif
 363
 364         /*
 365          * Turn up the interface
 366          */
 367         flags = IFF_UP;
 368         if (ioctl(s, SIOCGIFFLAGS, &ifr) >= 0) {
 369                 bzero(&ifr, sizeof(ifr));
 370                 snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "tap%d", tap_unit);
 371                 ifr.ifr_flags |= flags & 0xFFFF;
 372                 ifr.ifr_flagshigh |= flags >> 16;
 373                 if (ioctl(s, SIOCSIFFLAGS, &ifr) < 0) {
 374                         perror("Unable to set IFF_UP on tap interface");
 375                         exit(1);
 376                 }
 377         }
 378
 379         /*
 380          * If a bridge was specified associate the tap interface with the
 381          * bridge.
 382          */
 383         if (localBridge) {
 384                 struct ifbreq ifbr;
 385                 struct ifdrv ifd;
 386
 387                 /*
 388                  * Create the bridge if necessary.
 389                  */
 390                 bzero(&ifr, sizeof(ifr));
 391                 snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%s", localBridge);
 392                 if (ioctl(s, SIOCIFCREATE, &ifr) < 0) {
 393                         if (errno != EEXIST) {
 394                                 perror("Unable to create bridge interface");
 395                                 exit(1);
 396                         }
 397                 }
 398
 399
 400                 /*
 401                  * Add the tap interface to the bridge
 402                  */
 403                 bzero(&ifbr, sizeof(ifbr));
 404                 snprintf(ifbr.ifbr_ifsname, sizeof(ifbr.ifbr_ifsname),
 405                          "tap%d", tap_unit);
 406
 407                 bzero(&ifd, sizeof(ifd));
 408                 snprintf(ifd.ifd_name, sizeof(ifd.ifd_name), "%s", localBridge);
 409                 ifd.ifd_cmd = BRDGADD;
 410                 ifd.ifd_len = sizeof(ifbr);
 411                 ifd.ifd_data = &ifbr;
 412
 413                 if (ioctl(s, SIOCSDRVSPEC, &ifd) < 0) {
 414                         if (errno != EEXIST) {
 415                                 perror("Unable to add tap ifc to bridge!");
 416                                 exit(1);
 417                         }
 418                 }
 419         }
 420         close(s);
 421 }
 422
 423 /*
 424  * Connect to the remote machine with ssh and set up a stream
 425  */
 426 static void
 427 vknet_execssh(int fdin, int fdout, int compressOpt,
 428               const char *remoteSide, const char *remoteBridge)
 429 {
 430         char *remoteHost;
 431         char *remotePath;
 432         const char *av[24];
 433         int ac;
 434         pid_t pid;
 435
 436         /*
 437          * Fork / parent returns.
 438          */
 439         if ((pid = fork()) > 0)
 440                 return;
 441         if (pid < 0) {
 442                 perror("fork");
 443                 exit(1);
 444         }
 445
 446         /*
 447          * Setup stdin, stdout
 448          */
 449         assert(fdin > 2);
 450         assert(fdout > 2);
 451         dup2(fdin, 0);
 452         dup2(fdout, 1);
 453         close(fdin);
 454         close(fdout);
 455
 456         /*
 457          * Set up arguments
 458          */
 459         remoteHost = strdup(remoteSide);
 460         if ((remotePath = strchr(remoteHost, ':')) != NULL) {
 461                 *remotePath++ = 0;
 462         } else {
 463                 remotePath = strdup("/dev/vknet");
 464         }
 465         ac = 0;
 466         av[ac++] = "ssh";
 467         if (compressOpt)
 468                 av[ac++] = "-C";
 469         av[ac++] = "-x";
 470         av[ac++] = "-T";
 471         av[ac++] = "-e";
 472         av[ac++] = "none";
 473         av[ac++] = remoteHost;
 474         av[ac++] = "exec";
 475         av[ac++] = "vknet";
 476         av[ac++] = "-S";
 477         if (remoteBridge) {
 478                 av[ac++] = "-b";
 479                 av[ac++] = remoteBridge;
 480         }
 481         av[ac++] = remotePath;
 482         av[ac++] = NULL;
 483         execv("/usr/bin/ssh", (void *)av);
 484 }
 485
 486 /*
 487  * Misc
 488  */
 489 static
 490 void
 491 usage(void)
 492 {
 493         fprintf(stderr,
 494                 "vknet [-C] [-b local_bridge] [-B remote_bridge] local remote\n"
 495                 "vknet -S [-b local_bridge] local\n"
 496         );
 497         exit(1);
 498 }
 499