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