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 [-C] [-b local-bridge] [-B remote-bridge] [-r delay[:retries]]
  38  *       local-spec [user@]remote[:remote-spec]
  39  * vknet -S [-b local-bridge] local-spec        (server mode)
  40  *
  41  * Connect a SOCK_SEQPACKET socket or TUN device on the local host with
  42  * a SOCK_SEQPACKET socket or TUN device on the remote host through a SSH
  43  * connection.  When a TUN device is specified it may be optionally bridged.
  44  *
  45  * This program expects packetized reads and writes on the local and remote
  46  * sides and will re-block them over the SSH stream.
  47  */
  48
  49 #include "vknet.h"
  50
  51 static void vknet_blastaway(ioinfo_t ios, ioinfo_t iod);
  52 static void *vknet_stream(void *arg);
  53 static void vknet_connect(ioinfo_t ios,
  54                           const char *localSide, const char *localBridge);
  55 static pid_t vknet_execssh(int fdin, int fdout, int compressOpt,
  56                            const char *remoteSide, const char *remoteBridge);
  57 static void usage(void);
  58
  59 pthread_mutex_t MasterLock;
  60
  61 int
  62 main(int ac, char **av)
  63 {
  64         int compressOpt = 0;
  65         int remoteOpt = 0;
  66         const char *localBridge = NULL;
  67         const char *remoteBridge = NULL;
  68         const char *localSide;
  69         const char *remoteSide;
  70         char *ptr;
  71         int c;
  72         int retriesOpt = -1;
  73         int timeoutOpt = -1;
  74         pid_t sshpid = -1;
  75         pid_t p;
  76         struct ioinfo ios;
  77         struct ioinfo iod;
  78
  79         while ((c = getopt(ac, av, "b:B:r:CS")) != -1) {
  80                 switch (c) {
  81                 case 'b':
  82                         localBridge = optarg;
  83                         break;
  84                 case 'B':
  85                         remoteBridge = optarg;
  86                         break;
  87                 case 'r':
  88                         timeoutOpt = strtol(optarg, &ptr, 0);
  89                         if (ptr && *ptr == ':')
  90                                 retriesOpt = strtol(ptr + 1, NULL, 0);
  91                         break;
  92                 case 'S':
  93                         remoteOpt = 1;
  94                         break;
  95                 case 'C':
  96                         compressOpt = 1;
  97                         break;
  98                 default:
  99                         usage();
 100                 }
 101         }
 102         av += optind;
 103         ac -= optind;
 104
 105         /*
 106          * Local and remote arguments.
 107          */
 108         if (remoteOpt) {
 109                 if (ac != 1)
 110                         usage();
 111                 localSide = av[0];
 112                 remoteSide = NULL;
 113         } else {
 114                 if (ac != 2)
 115                         usage();
 116                 localSide = av[0];
 117                 remoteSide = av[1];
 118         }
 119
 120         pthread_mutex_init(&MasterLock, NULL);
 121
 122 retry:
 123         /*
 124          * Setup connections
 125          */
 126         vknet_connect(&ios, localSide, localBridge);
 127         if (remoteOpt) {
 128                 iod.fdin = 0;
 129                 iod.fdout = 1;
 130         } else {
 131                 int fds[2];
 132
 133                 if (pipe(fds) < 0) {
 134                         perror("pipe");
 135                         exit(1);
 136                 }
 137                 sshpid = vknet_execssh(fds[1], fds[1], compressOpt,
 138                               remoteSide, remoteBridge);
 139                 close(fds[1]);
 140                 iod.fdin = fds[0];
 141                 iod.fdout = fds[0];
 142         }
 143
 144         /*
 145          * Blast away, timeout/retry on failure
 146          */
 147         vknet_blastaway(&ios, &iod);
 148
 149         /*
 150          * Terminate child process
 151          */
 152         if (sshpid > 0) {
 153                 if (kill(sshpid, SIGTERM) != 0)
 154                         perror("kill");
 155                 while ((p = waitpid(sshpid, NULL, 0)) != sshpid) {
 156                         if (p < 0 && errno != EINTR)
 157                                 break;
 158                 }
 159                 sshpid = -1;
 160         }
 161
 162         /*
 163          * Handle timeout/retries
 164          */
 165         if (timeoutOpt >= 0 && retriesOpt != 0) {
 166                 printf("timeout %d retries %d\n", timeoutOpt, retriesOpt);
 167                 if (timeoutOpt > 0)
 168                         sleep(timeoutOpt);
 169                 if (retriesOpt > 0)
 170                         --retriesOpt;
 171                 goto retry;
 172         }
 173         exit(0);
 174 }
 175
 176 static void
 177 vknet_blastaway(ioinfo_t ios, ioinfo_t iod)
 178 {
 179         struct streaminfo stream1;
 180         struct streaminfo stream2;
 181
 182         pthread_mutex_lock(&MasterLock);
 183         stream1.fdin = ios->fdin;
 184         stream1.fdout = iod->fdout;
 185         stream1.flags = REBLOCK_OUT;
 186         stream1.other = &stream2;
 187         stream2.fdin = iod->fdin;
 188         stream2.fdout = ios->fdout;
 189         stream2.flags = REBLOCK_IN;
 190         stream2.other = &stream1;
 191         pthread_create(&stream1.thread, NULL, vknet_stream, &stream1);
 192         pthread_create(&stream2.thread, NULL, vknet_stream, &stream2);
 193         pthread_mutex_unlock(&MasterLock);
 194         pthread_join(stream1.thread, NULL);
 195         pthread_join(stream2.thread, NULL);
 196 }
 197
 198 /*
 199  * Transfer packets between two descriptors
 200  */
 201 static
 202 void *
 203 vknet_stream(void *arg)
 204 {
 205         streaminfo_t stream = arg;
 206         struct blkhead head;
 207         u_int8_t *pkt;
 208         int bytes;
 209         int n;
 210         int r;
 211
 212         /*
 213          * Synchronize with master thread, then loop
 214          */
 215         pthread_mutex_lock(&MasterLock);
 216         pthread_mutex_unlock(&MasterLock);
 217
 218         pkt = malloc(MAXPKT);
 219
 220         for (;;) {
 221                 /*
 222                  * Input side
 223                  */
 224                 if (stream->flags & REBLOCK_IN) {
 225                         bytes = sizeof(head);
 226                         for (n = 0; n < bytes; n += r) {
 227                                 r = read(stream->fdin, (char *)&head + n,
 228                                          bytes - n);
 229                                 if (r <= 0)
 230                                         break;
 231                         }
 232                         if (n != bytes)
 233                                 break;
 234                         if (le32toh(head.magic) != MAGIC)
 235                                 break;
 236                         bytes = le32toh(head.bytes);
 237                         if (bytes <= 0 || bytes > MAXPKT)
 238                                 break;
 239                         for (n = 0; n < bytes; n += r) {
 240                                 r = read(stream->fdin, pkt + n, bytes - n);
 241                                 if (r <= 0)
 242                                         break;
 243                         }
 244                         if (n != bytes)
 245                                 break;
 246                 } else {
 247                         bytes = read(stream->fdin, pkt, MAXPKT);
 248                         if (bytes <= 0)
 249                                 break;
 250                 }
 251
 252                 /*
 253                  * Output side
 254                  */
 255                 if (stream->flags & REBLOCK_OUT) {
 256                         head.magic = htole32(MAGIC);
 257                         head.bytes = htole32(bytes);
 258                         if (write(stream->fdout, &head, sizeof(head)) != sizeof(head))
 259                                 break;
 260                         if (write(stream->fdout, pkt, bytes) != bytes)
 261                                 break;
 262                 } else {
 263                         if (write(stream->fdout, pkt, bytes) != bytes)
 264                                 break;
 265                 }
 266         }
 267         free(pkt);
 268         close(stream->fdin);
 269         close(stream->fdout);
 270         pthread_cancel(stream->other->thread);
 271         pthread_exit(NULL);
 272 }
 273
 274 /*
 275  * vknet_connect() - Connect to local side, optionally find or bridge the tap
 276  *                   interface.
 277  */
 278 static void
 279 vknet_connect(ioinfo_t io, const char *localSide, const char *localBridge)
 280 {
 281         struct ifreq ifr;
 282         struct ifaliasreq ifra;
 283         char *buf = NULL;
 284         int tap_fd;
 285         int tap_unit;
 286         int i;
 287         int s;
 288         int flags;
 289
 290         tap_unit = -1;
 291         tap_fd = -1;
 292
 293         if (strcmp(localSide, "auto") == 0) {
 294                 for (i = 0; ; ++i) {
 295                         asprintf(&buf, "/dev/tap%d", i);
 296                         tap_fd = open(buf, O_RDWR | O_NONBLOCK);
 297                         free(buf);
 298                         if (tap_fd >= 0 || errno == ENOENT) {
 299                                 tap_unit = i;
 300                                 break;
 301                         }
 302                 }
 303         } else if (strncmp(localSide, "tap", 3) == 0) {
 304                 asprintf(&buf, "/dev/%s", localSide);
 305                 tap_fd = open(buf, O_RDWR | O_NONBLOCK);
 306                 tap_unit = strtol(localSide + 3, NULL, 10);
 307                 free(buf);
 308         } else if ((tap_fd = open(localSide, O_RDWR | O_NONBLOCK)) >= 0) {
 309                 const char *ptr = localSide + strlen(localSide);
 310                 while (ptr > localSide && ptr[-1] >= '0' && ptr[-1] <= '9')
 311                         --ptr;
 312                 tap_unit = strtol(ptr, NULL, 10);
 313         } else {
 314                 struct sockaddr_un sunx;
 315                 int len;
 316
 317                 snprintf(sunx.sun_path, sizeof(sunx.sun_path), "%s", localSide);
 318                 len = offsetof(struct sockaddr_un,
 319                                sun_path[strlen(sunx.sun_path)]);
 320                 ++len;  /* include nul */
 321                 sunx.sun_family = AF_UNIX;
 322                 sunx.sun_len = len;
 323
 324                 tap_fd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
 325                 if (tap_fd >= 0)         {
 326                         if (connect(tap_fd, (void *)&sunx, len) < 0) {
 327                                 close(tap_fd);
 328                                 tap_fd = -1;
 329                         }
 330                 }
 331         }
 332
 333         if (tap_fd < 0) {
 334                 err(1, "Unable to connect to %s", localSide);
 335                 /* NOT REACHED */
 336         }
 337
 338         fcntl(tap_fd, F_SETFL, 0);
 339         io->fdin = tap_fd;
 340         io->fdout = tap_fd;
 341
 342         /*
 343          * If this isn't a TAP device we are done.
 344          */
 345         if (tap_unit < 0)
 346                 return;
 347
 348         /*
 349          * Bring up the TAP interface
 350          */
 351         bzero(&ifr, sizeof(ifr));
 352         bzero(&ifra, sizeof(ifra));
 353         snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "tap%d", tap_unit);
 354         snprintf(ifra.ifra_name, sizeof(ifra.ifra_name), "tap%d", tap_unit);
 355
 356         s = socket(AF_INET, SOCK_DGRAM, 0);
 357
 358 #if 0
 359         /*
 360          * Set the interface address if in Secure mode.
 361          */
 362         if (SecureOpt) {
 363                 struct sockaddr_in *in;
 364
 365                 in = (void *)&ifra.ifra_addr;
 366                 in->sin_family = AF_INET;
 367                 in->sin_len = sizeof(ifra.ifra_addr);
 368                 in->sin_addr = NetAddress;
 369                 in = (void *)&ifra.ifra_mask;
 370                 in->sin_family = AF_INET;
 371                 in->sin_len = sizeof(ifra.ifra_mask);
 372                 in->sin_addr = NetMask;
 373                 if (ioctl(s, SIOCAIFADDR, &ifra) < 0) {
 374                         perror("Unable to set address on tap interface");
 375                         exit(1);
 376                 }
 377         }
 378 #endif
 379
 380         /*
 381          * Turn up the interface
 382          */
 383         flags = IFF_UP;
 384         if (ioctl(s, SIOCGIFFLAGS, &ifr) >= 0) {
 385                 bzero(&ifr, sizeof(ifr));
 386                 snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "tap%d", tap_unit);
 387                 ifr.ifr_flags |= flags & 0xFFFF;
 388                 ifr.ifr_flagshigh |= flags >> 16;
 389                 if (ioctl(s, SIOCSIFFLAGS, &ifr) < 0) {
 390                         perror("Unable to set IFF_UP on tap interface");
 391                         exit(1);
 392                 }
 393         }
 394
 395         /*
 396          * If a bridge was specified associate the tap interface with the
 397          * bridge.
 398          */
 399         if (localBridge) {
 400                 struct ifbreq ifbr;
 401                 struct ifdrv ifd;
 402
 403                 /*
 404                  * Create the bridge if necessary.
 405                  */
 406                 bzero(&ifr, sizeof(ifr));
 407                 snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%s", localBridge);
 408                 if (ioctl(s, SIOCIFCREATE, &ifr) < 0) {
 409                         if (errno != EEXIST) {
 410                                 perror("Unable to create bridge interface");
 411                                 exit(1);
 412                         }
 413                 }
 414
 415
 416                 /*
 417                  * Add the tap interface to the bridge
 418                  */
 419                 bzero(&ifbr, sizeof(ifbr));
 420                 snprintf(ifbr.ifbr_ifsname, sizeof(ifbr.ifbr_ifsname),
 421                          "tap%d", tap_unit);
 422
 423                 bzero(&ifd, sizeof(ifd));
 424                 snprintf(ifd.ifd_name, sizeof(ifd.ifd_name), "%s", localBridge);
 425                 ifd.ifd_cmd = BRDGADD;
 426                 ifd.ifd_len = sizeof(ifbr);
 427                 ifd.ifd_data = &ifbr;
 428
 429                 if (ioctl(s, SIOCSDRVSPEC, &ifd) < 0) {
 430                         if (errno != EEXIST) {
 431                                 perror("Unable to add tap ifc to bridge!");
 432                                 exit(1);
 433                         }
 434                 }
 435         }
 436         close(s);
 437 }
 438
 439 /*
 440  * Connect to the remote machine with ssh and set up a stream
 441  */
 442 static pid_t
 443 vknet_execssh(int fdin, int fdout, int compressOpt,
 444               const char *remoteSide, const char *remoteBridge)
 445 {
 446         char *remoteHost;
 447         char *remotePath;
 448         const char *av[24];
 449         int ac;
 450         pid_t pid;
 451
 452         /*
 453          * Fork / parent returns.
 454          */
 455         if ((pid = fork()) > 0)
 456                 return pid;
 457         if (pid < 0) {
 458                 perror("fork");
 459                 exit(1);
 460         }
 461
 462         /*
 463          * Setup stdin, stdout
 464          */
 465         assert(fdin > 2);
 466         assert(fdout > 2);
 467         dup2(fdin, 0);
 468         dup2(fdout, 1);
 469         close(fdin);
 470         close(fdout);
 471
 472         /*
 473          * Set up arguments
 474          */
 475         remoteHost = strdup(remoteSide);
 476         if ((remotePath = strchr(remoteHost, ':')) != NULL) {
 477                 *remotePath++ = 0;
 478         } else {
 479                 remotePath = strdup("/var/run/vknet");
 480         }
 481         ac = 0;
 482         av[ac++] = "ssh";
 483         if (compressOpt)
 484                 av[ac++] = "-C";
 485         av[ac++] = "-x";
 486         av[ac++] = "-T";
 487         av[ac++] = "-e";
 488         av[ac++] = "none";
 489         av[ac++] = remoteHost;
 490         av[ac++] = "exec";
 491         av[ac++] = "vknet";
 492         av[ac++] = "-S";
 493         if (remoteBridge) {
 494                 av[ac++] = "-b";
 495                 av[ac++] = remoteBridge;
 496         }
 497         av[ac++] = remotePath;
 498         av[ac++] = NULL;
 499         execv("/usr/bin/ssh", (void *)av);
 500         exit(1);
 501 }
 502
 503 /*
 504  * Misc
 505  */
 506 static
 507 void
 508 usage(void)
 509 {
 510         fprintf(stderr,
 511                 "vknet [-C] [-b local-bridge] [-B remote-bridge] [-r delay[:retries]]\n"
 512                 "      local-spec [user@]remote[:remote-spec]\n"
 513                 "vknet -S [-b local-bridge] local-spec\n"
 514         );
 515         exit(1);
 516 }
 517