tests/vhost-user-bridge.c

   1 /*
   2  * Vhost User Bridge
   3  *
   4  * Copyright (c) 2015 Red Hat, Inc.
   5  *
   6  * Authors:
   7  *  Victor Kaplansky <victork@redhat.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or
  10  * later.  See the COPYING file in the top-level directory.
  11  */
  12
  13 /*
  14  * TODO:
  15  *     - main should get parameters from the command line.
  16  *     - implement all request handlers. Still not implemented:
  17  *          vubr_get_queue_num_exec()
  18  *          vubr_send_rarp_exec()
  19  *     - test for broken requests and virtqueue.
  20  *     - implement features defined by Virtio 1.0 spec.
  21  *     - support mergeable buffers and indirect descriptors.
  22  *     - implement clean shutdown.
  23  *     - implement non-blocking writes to UDP backend.
  24  *     - implement polling strategy.
  25  *     - implement clean starting/stopping of vq processing
  26  *     - implement clean starting/stopping of used and buffers
  27  *       dirty page logging.
  28  */
  29
  30 #define _FILE_OFFSET_BITS 64
  31
  32 #include "qemu/osdep.h"
  33 #include "qemu/atomic.h"
  34 #include "qemu/iov.h"
  35 #include "standard-headers/linux/virtio_net.h"
  36 #include "contrib/libvhost-user/libvhost-user.h"
  37
  38 #define VHOST_USER_BRIDGE_DEBUG 1
  39
  40 #define DPRINT(...) \
  41     do { \
  42         if (VHOST_USER_BRIDGE_DEBUG) { \
  43             printf(__VA_ARGS__); \
  44         } \
  45     } while (0)
  46
  47 typedef void (*CallbackFunc)(int sock, void *ctx);
  48
  49 typedef struct Event {
  50     void *ctx;
  51     CallbackFunc callback;
  52 } Event;
  53
  54 typedef struct Dispatcher {
  55     int max_sock;
  56     fd_set fdset;
  57     Event events[FD_SETSIZE];
  58 } Dispatcher;
  59
  60 typedef struct VubrDev {
  61     VuDev vudev;
  62     Dispatcher dispatcher;
  63     int backend_udp_sock;
  64     struct sockaddr_in backend_udp_dest;
  65     int hdrlen;
  66     int sock;
  67     int ready;
  68     int quit;
  69     struct {
  70         int fd;
  71         void *addr;
  72         pthread_t thread;
  73     } notifier;
  74 } VubrDev;
  75
  76 static void
  77 vubr_die(const char *s)
  78 {
  79     perror(s);
  80     exit(1);
  81 }
  82
  83 static int
  84 dispatcher_init(Dispatcher *dispr)
  85 {
  86     FD_ZERO(&dispr->fdset);
  87     dispr->max_sock = -1;
  88     return 0;
  89 }
  90
  91 static int
  92 dispatcher_add(Dispatcher *dispr, int sock, void *ctx, CallbackFunc cb)
  93 {
  94     if (sock >= FD_SETSIZE) {
  95         fprintf(stderr,
  96                 "Error: Failed to add new event. sock %d should be less than %d\n",
  97                 sock, FD_SETSIZE);
  98         return -1;
  99     }
 100
 101     dispr->events[sock].ctx = ctx;
 102     dispr->events[sock].callback = cb;
 103
 104     FD_SET(sock, &dispr->fdset);
 105     if (sock > dispr->max_sock) {
 106         dispr->max_sock = sock;
 107     }
 108     DPRINT("Added sock %d for watching. max_sock: %d\n",
 109            sock, dispr->max_sock);
 110     return 0;
 111 }
 112
 113 static int
 114 dispatcher_remove(Dispatcher *dispr, int sock)
 115 {
 116     if (sock >= FD_SETSIZE) {
 117         fprintf(stderr,
 118                 "Error: Failed to remove event. sock %d should be less than %d\n",
 119                 sock, FD_SETSIZE);
 120         return -1;
 121     }
 122
 123     FD_CLR(sock, &dispr->fdset);
 124     DPRINT("Sock %d removed from dispatcher watch.\n", sock);
 125     return 0;
 126 }
 127
 128 /* timeout in us */
 129 static int
 130 dispatcher_wait(Dispatcher *dispr, uint32_t timeout)
 131 {
 132     struct timeval tv;
 133     tv.tv_sec = timeout / 1000000;
 134     tv.tv_usec = timeout % 1000000;
 135
 136     fd_set fdset = dispr->fdset;
 137
 138     /* wait until some of sockets become readable. */
 139     int rc = select(dispr->max_sock + 1, &fdset, 0, 0, &tv);
 140
 141     if (rc == -1) {
 142         vubr_die("select");
 143     }
 144
 145     /* Timeout */
 146     if (rc == 0) {
 147         return 0;
 148     }
 149
 150     /* Now call callback for every ready socket. */
 151
 152     int sock;
 153     for (sock = 0; sock < dispr->max_sock + 1; sock++) {
 154         /* The callback on a socket can remove other sockets from the
 155          * dispatcher, thus we have to check that the socket is
 156          * still not removed from dispatcher's list
 157          */
 158         if (FD_ISSET(sock, &fdset) && FD_ISSET(sock, &dispr->fdset)) {
 159             Event *e = &dispr->events[sock];
 160             e->callback(sock, e->ctx);
 161         }
 162     }
 163
 164     return 0;
 165 }
 166
 167 static void
 168 vubr_handle_tx(VuDev *dev, int qidx)
 169 {
 170     VuVirtq *vq = vu_get_queue(dev, qidx);
 171     VubrDev *vubr = container_of(dev, VubrDev, vudev);
 172     int hdrlen = vubr->hdrlen;
 173     VuVirtqElement *elem = NULL;
 174
 175     assert(qidx % 2);
 176
 177     for (;;) {
 178         ssize_t ret;
 179         unsigned int out_num;
 180         struct iovec sg[VIRTQUEUE_MAX_SIZE], *out_sg;
 181
 182         elem = vu_queue_pop(dev, vq, sizeof(VuVirtqElement));
 183         if (!elem) {
 184             break;
 185         }
 186
 187         out_num = elem->out_num;
 188         out_sg = elem->out_sg;
 189         if (out_num < 1) {
 190             fprintf(stderr, "virtio-net header not in first element\n");
 191             break;
 192         }
 193         if (VHOST_USER_BRIDGE_DEBUG) {
 194             iov_hexdump(out_sg, out_num, stderr, "TX:", 1024);
 195         }
 196
 197         if (hdrlen) {
 198             unsigned sg_num = iov_copy(sg, ARRAY_SIZE(sg),
 199                                        out_sg, out_num,
 200                                        hdrlen, -1);
 201             out_num = sg_num;
 202             out_sg = sg;
 203         }
 204
 205         struct msghdr msg = {
 206             .msg_name = (struct sockaddr *) &vubr->backend_udp_dest,
 207             .msg_namelen = sizeof(struct sockaddr_in),
 208             .msg_iov = out_sg,
 209             .msg_iovlen = out_num,
 210         };
 211         do {
 212             ret = sendmsg(vubr->backend_udp_sock, &msg, 0);
 213         } while (ret == -1 && (errno == EAGAIN || errno == EINTR));
 214
 215         if (ret == -1) {
 216             vubr_die("sendmsg()");
 217         }
 218
 219         vu_queue_push(dev, vq, elem, 0);
 220         vu_queue_notify(dev, vq);
 221
 222         free(elem);
 223         elem = NULL;
 224     }
 225
 226     free(elem);
 227 }
 228
 229
 230 /* this function reverse the effect of iov_discard_front() it must be
 231  * called with 'front' being the original struct iovec and 'bytes'
 232  * being the number of bytes you shaved off
 233  */
 234 static void
 235 iov_restore_front(struct iovec *front, struct iovec *iov, size_t bytes)
 236 {
 237     struct iovec *cur;
 238
 239     for (cur = front; cur != iov; cur++) {
 240         assert(bytes >= cur->iov_len);
 241         bytes -= cur->iov_len;
 242     }
 243
 244     cur->iov_base -= bytes;
 245     cur->iov_len += bytes;
 246 }
 247
 248 static void
 249 iov_truncate(struct iovec *iov, unsigned iovc, size_t bytes)
 250 {
 251     unsigned i;
 252
 253     for (i = 0; i < iovc; i++, iov++) {
 254         if (bytes < iov->iov_len) {
 255             iov->iov_len = bytes;
 256             return;
 257         }
 258
 259         bytes -= iov->iov_len;
 260     }
 261
 262     assert(!"couldn't truncate iov");
 263 }
 264
 265 static void
 266 vubr_backend_recv_cb(int sock, void *ctx)
 267 {
 268     VubrDev *vubr = (VubrDev *) ctx;
 269     VuDev *dev = &vubr->vudev;
 270     VuVirtq *vq = vu_get_queue(dev, 0);
 271     VuVirtqElement *elem = NULL;
 272     struct iovec mhdr_sg[VIRTQUEUE_MAX_SIZE];
 273     struct virtio_net_hdr_mrg_rxbuf mhdr;
 274     unsigned mhdr_cnt = 0;
 275     int hdrlen = vubr->hdrlen;
 276     int i = 0;
 277     struct virtio_net_hdr hdr = {
 278         .flags = 0,
 279         .gso_type = VIRTIO_NET_HDR_GSO_NONE
 280     };
 281
 282     DPRINT("\n\n   ***   IN UDP RECEIVE CALLBACK    ***\n\n");
 283     DPRINT("    hdrlen = %d\n", hdrlen);
 284
 285     if (!vu_queue_enabled(dev, vq) ||
 286         !vu_queue_started(dev, vq) ||
 287         !vu_queue_avail_bytes(dev, vq, hdrlen, 0)) {
 288         DPRINT("Got UDP packet, but no available descriptors on RX virtq.\n");
 289         return;
 290     }
 291
 292     while (1) {
 293         struct iovec *sg;
 294         ssize_t ret, total = 0;
 295         unsigned int num;
 296
 297         elem = vu_queue_pop(dev, vq, sizeof(VuVirtqElement));
 298         if (!elem) {
 299             break;
 300         }
 301
 302         if (elem->in_num < 1) {
 303             fprintf(stderr, "virtio-net contains no in buffers\n");
 304             break;
 305         }
 306
 307         sg = elem->in_sg;
 308         num = elem->in_num;
 309         if (i == 0) {
 310             if (hdrlen == 12) {
 311                 mhdr_cnt = iov_copy(mhdr_sg, ARRAY_SIZE(mhdr_sg),
 312                                     sg, elem->in_num,
 313                                     offsetof(typeof(mhdr), num_buffers),
 314                                     sizeof(mhdr.num_buffers));
 315             }
 316             iov_from_buf(sg, elem->in_num, 0, &hdr, sizeof hdr);
 317             total += hdrlen;
 318             ret = iov_discard_front(&sg, &num, hdrlen);
 319             assert(ret == hdrlen);
 320         }
 321
 322         struct msghdr msg = {
 323             .msg_name = (struct sockaddr *) &vubr->backend_udp_dest,
 324             .msg_namelen = sizeof(struct sockaddr_in),
 325             .msg_iov = sg,
 326             .msg_iovlen = num,
 327             .msg_flags = MSG_DONTWAIT,
 328         };
 329         do {
 330             ret = recvmsg(vubr->backend_udp_sock, &msg, 0);
 331         } while (ret == -1 && (errno == EINTR));
 332
 333         if (i == 0) {
 334             iov_restore_front(elem->in_sg, sg, hdrlen);
 335         }
 336
 337         if (ret == -1) {
 338             if (errno == EWOULDBLOCK) {
 339                 vu_queue_rewind(dev, vq, 1);
 340                 break;
 341             }
 342
 343             vubr_die("recvmsg()");
 344         }
 345
 346         total += ret;
 347         iov_truncate(elem->in_sg, elem->in_num, total);
 348         vu_queue_fill(dev, vq, elem, total, i++);
 349
 350         free(elem);
 351         elem = NULL;
 352
 353         break;        /* could loop if DONTWAIT worked? */
 354     }
 355
 356     if (mhdr_cnt) {
 357         mhdr.num_buffers = i;
 358         iov_from_buf(mhdr_sg, mhdr_cnt,
 359                      0,
 360                      &mhdr.num_buffers, sizeof mhdr.num_buffers);
 361     }
 362
 363     vu_queue_flush(dev, vq, i);
 364     vu_queue_notify(dev, vq);
 365
 366     free(elem);
 367 }
 368
 369 static void
 370 vubr_receive_cb(int sock, void *ctx)
 371 {
 372     VubrDev *vubr = (VubrDev *)ctx;
 373
 374     if (!vu_dispatch(&vubr->vudev)) {
 375         fprintf(stderr, "Error while dispatching\n");
 376     }
 377 }
 378
 379 typedef struct WatchData {
 380     VuDev *dev;
 381     vu_watch_cb cb;
 382     void *data;
 383 } WatchData;
 384
 385 static void
 386 watch_cb(int sock, void *ctx)
 387 {
 388     struct WatchData *wd = ctx;
 389
 390     wd->cb(wd->dev, VU_WATCH_IN, wd->data);
 391 }
 392
 393 static void
 394 vubr_set_watch(VuDev *dev, int fd, int condition,
 395                vu_watch_cb cb, void *data)
 396 {
 397     VubrDev *vubr = container_of(dev, VubrDev, vudev);
 398     static WatchData watches[FD_SETSIZE];
 399     struct WatchData *wd = &watches[fd];
 400
 401     wd->cb = cb;
 402     wd->data = data;
 403     wd->dev = dev;
 404     dispatcher_add(&vubr->dispatcher, fd, wd, watch_cb);
 405 }
 406
 407 static void
 408 vubr_remove_watch(VuDev *dev, int fd)
 409 {
 410     VubrDev *vubr = container_of(dev, VubrDev, vudev);
 411
 412     dispatcher_remove(&vubr->dispatcher, fd);
 413 }
 414
 415 static int
 416 vubr_send_rarp_exec(VuDev *dev, VhostUserMsg *vmsg)
 417 {
 418     DPRINT("Function %s() not implemented yet.\n", __func__);
 419     return 0;
 420 }
 421
 422 static int
 423 vubr_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply)
 424 {
 425     switch (vmsg->request) {
 426     case VHOST_USER_SEND_RARP:
 427         *do_reply = vubr_send_rarp_exec(dev, vmsg);
 428         return 1;
 429     default:
 430         /* let the library handle the rest */
 431         return 0;
 432     }
 433
 434     return 0;
 435 }
 436
 437 static void
 438 vubr_set_features(VuDev *dev, uint64_t features)
 439 {
 440     VubrDev *vubr = container_of(dev, VubrDev, vudev);
 441
 442     if ((features & (1ULL << VIRTIO_F_VERSION_1)) ||
 443         (features & (1ULL << VIRTIO_NET_F_MRG_RXBUF))) {
 444         vubr->hdrlen = 12;
 445     } else {
 446         vubr->hdrlen = 10;
 447     }
 448 }
 449
 450 static uint64_t
 451 vubr_get_features(VuDev *dev)
 452 {
 453     return 1ULL << VIRTIO_NET_F_GUEST_ANNOUNCE |
 454         1ULL << VIRTIO_NET_F_MRG_RXBUF |
 455         1ULL << VIRTIO_F_VERSION_1;
 456 }
 457
 458 static void
 459 vubr_queue_set_started(VuDev *dev, int qidx, bool started)
 460 {
 461     VubrDev *vubr = container_of(dev, VubrDev, vudev);
 462     VuVirtq *vq = vu_get_queue(dev, qidx);
 463
 464     if (started && vubr->notifier.fd >= 0) {
 465         vu_set_queue_host_notifier(dev, vq, vubr->notifier.fd,
 466                                    getpagesize(),
 467                                    qidx * getpagesize());
 468     }
 469
 470     if (qidx % 2 == 1) {
 471         vu_set_queue_handler(dev, vq, started ? vubr_handle_tx : NULL);
 472     }
 473 }
 474
 475 static void
 476 vubr_panic(VuDev *dev, const char *msg)
 477 {
 478     VubrDev *vubr = container_of(dev, VubrDev, vudev);
 479
 480     fprintf(stderr, "PANIC: %s\n", msg);
 481
 482     dispatcher_remove(&vubr->dispatcher, dev->sock);
 483     vubr->quit = 1;
 484 }
 485
 486 static bool
 487 vubr_queue_is_processed_in_order(VuDev *dev, int qidx)
 488 {
 489     return true;
 490 }
 491
 492 static const VuDevIface vuiface = {
 493     .get_features = vubr_get_features,
 494     .set_features = vubr_set_features,
 495     .process_msg = vubr_process_msg,
 496     .queue_set_started = vubr_queue_set_started,
 497     .queue_is_processed_in_order = vubr_queue_is_processed_in_order,
 498 };
 499
 500 static void
 501 vubr_accept_cb(int sock, void *ctx)
 502 {
 503     VubrDev *dev = (VubrDev *)ctx;
 504     int conn_fd;
 505     struct sockaddr_un un;
 506     socklen_t len = sizeof(un);
 507
 508     conn_fd = accept(sock, (struct sockaddr *) &un, &len);
 509     if (conn_fd == -1) {
 510         vubr_die("accept()");
 511     }
 512     DPRINT("Got connection from remote peer on sock %d\n", conn_fd);
 513
 514     vu_init(&dev->vudev,
 515             conn_fd,
 516             vubr_panic,
 517             vubr_set_watch,
 518             vubr_remove_watch,
 519             &vuiface);
 520
 521     dispatcher_add(&dev->dispatcher, conn_fd, ctx, vubr_receive_cb);
 522     dispatcher_remove(&dev->dispatcher, sock);
 523 }
 524
 525 static VubrDev *
 526 vubr_new(const char *path, bool client)
 527 {
 528     VubrDev *dev = (VubrDev *) calloc(1, sizeof(VubrDev));
 529     struct sockaddr_un un;
 530     CallbackFunc cb;
 531     size_t len;
 532
 533     /* Get a UNIX socket. */
 534     dev->sock = socket(AF_UNIX, SOCK_STREAM, 0);
 535     if (dev->sock == -1) {
 536         vubr_die("socket");
 537     }
 538
 539     dev->notifier.fd = -1;
 540
 541     un.sun_family = AF_UNIX;
 542     strcpy(un.sun_path, path);
 543     len = sizeof(un.sun_family) + strlen(path);
 544
 545     if (!client) {
 546         unlink(path);
 547
 548         if (bind(dev->sock, (struct sockaddr *) &un, len) == -1) {
 549             vubr_die("bind");
 550         }
 551
 552         if (listen(dev->sock, 1) == -1) {
 553             vubr_die("listen");
 554         }
 555         cb = vubr_accept_cb;
 556
 557         DPRINT("Waiting for connections on UNIX socket %s ...\n", path);
 558     } else {
 559         if (connect(dev->sock, (struct sockaddr *)&un, len) == -1) {
 560             vubr_die("connect");
 561         }
 562         vu_init(&dev->vudev,
 563                 dev->sock,
 564                 vubr_panic,
 565                 vubr_set_watch,
 566                 vubr_remove_watch,
 567                 &vuiface);
 568         cb = vubr_receive_cb;
 569     }
 570
 571     dispatcher_init(&dev->dispatcher);
 572
 573     dispatcher_add(&dev->dispatcher, dev->sock, (void *)dev, cb);
 574
 575     return dev;
 576 }
 577
 578 static void *notifier_thread(void *arg)
 579 {
 580     VuDev *dev = (VuDev *)arg;
 581     VubrDev *vubr = container_of(dev, VubrDev, vudev);
 582     int pagesize = getpagesize();
 583     int qidx;
 584
 585     while (true) {
 586         for (qidx = 0; qidx < VHOST_MAX_NR_VIRTQUEUE; qidx++) {
 587             uint16_t *n = vubr->notifier.addr + pagesize * qidx;
 588
 589             if (*n == qidx) {
 590                 *n = 0xffff;
 591                 /* We won't miss notifications if we reset
 592                  * the memory first. */
 593                 smp_mb();
 594
 595                 DPRINT("Got a notification for queue%d via host notifier.\n",
 596                        qidx);
 597
 598                 if (qidx % 2 == 1) {
 599                     vubr_handle_tx(dev, qidx);
 600                 }
 601             }
 602             usleep(1000);
 603         }
 604     }
 605
 606     return NULL;
 607 }
 608
 609 static void
 610 vubr_host_notifier_setup(VubrDev *dev)
 611 {
 612     char template[] = "/tmp/vubr-XXXXXX";
 613     pthread_t thread;
 614     size_t length;
 615     void *addr;
 616     int fd;
 617
 618     length = getpagesize() * VHOST_MAX_NR_VIRTQUEUE;
 619
 620     fd = mkstemp(template);
 621     if (fd < 0) {
 622         vubr_die("mkstemp()");
 623     }
 624
 625     if (posix_fallocate(fd, 0, length) != 0) {
 626         vubr_die("posix_fallocate()");
 627     }
 628
 629     addr = mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 630     if (addr == MAP_FAILED) {
 631         vubr_die("mmap()");
 632     }
 633
 634     memset(addr, 0xff, length);
 635
 636     if (pthread_create(&thread, NULL, notifier_thread, &dev->vudev) != 0) {
 637         vubr_die("pthread_create()");
 638     }
 639
 640     dev->notifier.fd = fd;
 641     dev->notifier.addr = addr;
 642     dev->notifier.thread = thread;
 643 }
 644
 645 static void
 646 vubr_set_host(struct sockaddr_in *saddr, const char *host)
 647 {
 648     if (isdigit(host[0])) {
 649         if (!inet_aton(host, &saddr->sin_addr)) {
 650             fprintf(stderr, "inet_aton() failed.\n");
 651             exit(1);
 652         }
 653     } else {
 654         struct hostent *he = gethostbyname(host);
 655
 656         if (!he) {
 657             fprintf(stderr, "gethostbyname() failed.\n");
 658             exit(1);
 659         }
 660         saddr->sin_addr = *(struct in_addr *)he->h_addr;
 661     }
 662 }
 663
 664 static void
 665 vubr_backend_udp_setup(VubrDev *dev,
 666                        const char *local_host,
 667                        const char *local_port,
 668                        const char *remote_host,
 669                        const char *remote_port)
 670 {
 671     int sock;
 672     const char *r;
 673
 674     int lport, rport;
 675
 676     lport = strtol(local_port, (char **)&r, 0);
 677     if (r == local_port) {
 678         fprintf(stderr, "lport parsing failed.\n");
 679         exit(1);
 680     }
 681
 682     rport = strtol(remote_port, (char **)&r, 0);
 683     if (r == remote_port) {
 684         fprintf(stderr, "rport parsing failed.\n");
 685         exit(1);
 686     }
 687
 688     struct sockaddr_in si_local = {
 689         .sin_family = AF_INET,
 690         .sin_port = htons(lport),
 691     };
 692
 693     vubr_set_host(&si_local, local_host);
 694
 695     /* setup destination for sends */
 696     dev->backend_udp_dest = (struct sockaddr_in) {
 697         .sin_family = AF_INET,
 698         .sin_port = htons(rport),
 699     };
 700     vubr_set_host(&dev->backend_udp_dest, remote_host);
 701
 702     sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 703     if (sock == -1) {
 704         vubr_die("socket");
 705     }
 706
 707     if (bind(sock, (struct sockaddr *)&si_local, sizeof(si_local)) == -1) {
 708         vubr_die("bind");
 709     }
 710
 711     dev->backend_udp_sock = sock;
 712     dispatcher_add(&dev->dispatcher, sock, dev, vubr_backend_recv_cb);
 713     DPRINT("Waiting for data from udp backend on %s:%d...\n",
 714            local_host, lport);
 715 }
 716
 717 static void
 718 vubr_run(VubrDev *dev)
 719 {
 720     while (!dev->quit) {
 721         /* timeout 200ms */
 722         dispatcher_wait(&dev->dispatcher, 200000);
 723         /* Here one can try polling strategy. */
 724     }
 725 }
 726
 727 static int
 728 vubr_parse_host_port(const char **host, const char **port, const char *buf)
 729 {
 730     char *p = strchr(buf, ':');
 731
 732     if (!p) {
 733         return -1;
 734     }
 735     *p = '\0';
 736     *host = strdup(buf);
 737     *port = strdup(p + 1);
 738     return 0;
 739 }
 740
 741 #define DEFAULT_UD_SOCKET "/tmp/vubr.sock"
 742 #define DEFAULT_LHOST "127.0.0.1"
 743 #define DEFAULT_LPORT "4444"
 744 #define DEFAULT_RHOST "127.0.0.1"
 745 #define DEFAULT_RPORT "5555"
 746
 747 static const char *ud_socket_path = DEFAULT_UD_SOCKET;
 748 static const char *lhost = DEFAULT_LHOST;
 749 static const char *lport = DEFAULT_LPORT;
 750 static const char *rhost = DEFAULT_RHOST;
 751 static const char *rport = DEFAULT_RPORT;
 752
 753 int
 754 main(int argc, char *argv[])
 755 {
 756     VubrDev *dev;
 757     int opt;
 758     bool client = false;
 759     bool host_notifier = false;
 760
 761     while ((opt = getopt(argc, argv, "l:r:u:cH")) != -1) {
 762
 763         switch (opt) {
 764         case 'l':
 765             if (vubr_parse_host_port(&lhost, &lport, optarg) < 0) {
 766                 goto out;
 767             }
 768             break;
 769         case 'r':
 770             if (vubr_parse_host_port(&rhost, &rport, optarg) < 0) {
 771                 goto out;
 772             }
 773             break;
 774         case 'u':
 775             ud_socket_path = strdup(optarg);
 776             break;
 777         case 'c':
 778             client = true;
 779             break;
 780         case 'H':
 781             host_notifier = true;
 782             break;
 783         default:
 784             goto out;
 785         }
 786     }
 787
 788     DPRINT("ud socket: %s (%s)\n", ud_socket_path,
 789            client ? "client" : "server");
 790     DPRINT("local:     %s:%s\n", lhost, lport);
 791     DPRINT("remote:    %s:%s\n", rhost, rport);
 792
 793     dev = vubr_new(ud_socket_path, client);
 794     if (!dev) {
 795         return 1;
 796     }
 797
 798     if (host_notifier) {
 799         vubr_host_notifier_setup(dev);
 800     }
 801
 802     vubr_backend_udp_setup(dev, lhost, lport, rhost, rport);
 803     vubr_run(dev);
 804
 805     vu_deinit(&dev->vudev);
 806
 807     return 0;
 808
 809 out:
 810     fprintf(stderr, "Usage: %s ", argv[0]);
 811     fprintf(stderr, "[-c] [-H] [-u ud_socket_path] [-l lhost:lport] [-r rhost:rport]\n");
 812     fprintf(stderr, "\t-u path to unix doman socket. default: %s\n",
 813             DEFAULT_UD_SOCKET);
 814     fprintf(stderr, "\t-l local host and port. default: %s:%s\n",
 815             DEFAULT_LHOST, DEFAULT_LPORT);
 816     fprintf(stderr, "\t-r remote host and port. default: %s:%s\n",
 817             DEFAULT_RHOST, DEFAULT_RPORT);
 818     fprintf(stderr, "\t-c client mode\n");
 819     fprintf(stderr, "\t-H use host notifier\n");
 820
 821     return 1;
 822 }