1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30#define _FILE_OFFSET_BITS 64
31
32#include "qemu/osdep.h"
33#include <sys/socket.h>
34#include <sys/un.h>
35#include <sys/unistd.h>
36#include <sys/eventfd.h>
37#include <arpa/inet.h>
38#include <netdb.h>
39#include <linux/vhost.h>
40
41#include "qemu/atomic.h"
42#include "standard-headers/linux/virtio_net.h"
43#include "standard-headers/linux/virtio_ring.h"
44
45#define VHOST_USER_BRIDGE_DEBUG 1
46
47#define DPRINT(...) \
48 do { \
49 if (VHOST_USER_BRIDGE_DEBUG) { \
50 printf(__VA_ARGS__); \
51 } \
52 } while (0)
53
54typedef void (*CallbackFunc)(int sock, void *ctx);
55
56typedef struct Event {
57 void *ctx;
58 CallbackFunc callback;
59} Event;
60
61typedef struct Dispatcher {
62 int max_sock;
63 fd_set fdset;
64 Event events[FD_SETSIZE];
65} Dispatcher;
66
67static void
68vubr_die(const char *s)
69{
70 perror(s);
71 exit(1);
72}
73
74static int
75dispatcher_init(Dispatcher *dispr)
76{
77 FD_ZERO(&dispr->fdset);
78 dispr->max_sock = -1;
79 return 0;
80}
81
82static int
83dispatcher_add(Dispatcher *dispr, int sock, void *ctx, CallbackFunc cb)
84{
85 if (sock >= FD_SETSIZE) {
86 fprintf(stderr,
87 "Error: Failed to add new event. sock %d should be less than %d\n",
88 sock, FD_SETSIZE);
89 return -1;
90 }
91
92 dispr->events[sock].ctx = ctx;
93 dispr->events[sock].callback = cb;
94
95 FD_SET(sock, &dispr->fdset);
96 if (sock > dispr->max_sock) {
97 dispr->max_sock = sock;
98 }
99 DPRINT("Added sock %d for watching. max_sock: %d\n",
100 sock, dispr->max_sock);
101 return 0;
102}
103
104
105
106static int
107dispatcher_remove(Dispatcher *dispr, int sock)
108{
109 if (sock >= FD_SETSIZE) {
110 fprintf(stderr,
111 "Error: Failed to remove event. sock %d should be less than %d\n",
112 sock, FD_SETSIZE);
113 return -1;
114 }
115
116 FD_CLR(sock, &dispr->fdset);
117 DPRINT("Sock %d removed from dispatcher watch.\n", sock);
118 return 0;
119}
120
121
122static int
123dispatcher_wait(Dispatcher *dispr, uint32_t timeout)
124{
125 struct timeval tv;
126 tv.tv_sec = timeout / 1000000;
127 tv.tv_usec = timeout % 1000000;
128
129 fd_set fdset = dispr->fdset;
130
131
132 int rc = select(dispr->max_sock + 1, &fdset, 0, 0, &tv);
133
134 if (rc == -1) {
135 vubr_die("select");
136 }
137
138
139 if (rc == 0) {
140 return 0;
141 }
142
143
144
145 int sock;
146 for (sock = 0; sock < dispr->max_sock + 1; sock++) {
147
148
149
150
151 if (FD_ISSET(sock, &fdset) && FD_ISSET(sock, &dispr->fdset)) {
152 Event *e = &dispr->events[sock];
153 e->callback(sock, e->ctx);
154 }
155 }
156
157 return 0;
158}
159
160typedef struct VubrVirtq {
161 int call_fd;
162 int kick_fd;
163 uint32_t size;
164 uint16_t last_avail_index;
165 uint16_t last_used_index;
166 struct vring_desc *desc;
167 struct vring_avail *avail;
168 struct vring_used *used;
169 uint64_t log_guest_addr;
170 int enable;
171} VubrVirtq;
172
173
174
175#define VHOST_MEMORY_MAX_NREGIONS 8
176#define VHOST_USER_F_PROTOCOL_FEATURES 30
177
178#define VIRTIO_F_VERSION_1 32
179
180#define VHOST_LOG_PAGE 4096
181
182enum VhostUserProtocolFeature {
183 VHOST_USER_PROTOCOL_F_MQ = 0,
184 VHOST_USER_PROTOCOL_F_LOG_SHMFD = 1,
185 VHOST_USER_PROTOCOL_F_RARP = 2,
186
187 VHOST_USER_PROTOCOL_F_MAX
188};
189
190#define VHOST_USER_PROTOCOL_FEATURE_MASK ((1 << VHOST_USER_PROTOCOL_F_MAX) - 1)
191
192typedef enum VhostUserRequest {
193 VHOST_USER_NONE = 0,
194 VHOST_USER_GET_FEATURES = 1,
195 VHOST_USER_SET_FEATURES = 2,
196 VHOST_USER_SET_OWNER = 3,
197 VHOST_USER_RESET_OWNER = 4,
198 VHOST_USER_SET_MEM_TABLE = 5,
199 VHOST_USER_SET_LOG_BASE = 6,
200 VHOST_USER_SET_LOG_FD = 7,
201 VHOST_USER_SET_VRING_NUM = 8,
202 VHOST_USER_SET_VRING_ADDR = 9,
203 VHOST_USER_SET_VRING_BASE = 10,
204 VHOST_USER_GET_VRING_BASE = 11,
205 VHOST_USER_SET_VRING_KICK = 12,
206 VHOST_USER_SET_VRING_CALL = 13,
207 VHOST_USER_SET_VRING_ERR = 14,
208 VHOST_USER_GET_PROTOCOL_FEATURES = 15,
209 VHOST_USER_SET_PROTOCOL_FEATURES = 16,
210 VHOST_USER_GET_QUEUE_NUM = 17,
211 VHOST_USER_SET_VRING_ENABLE = 18,
212 VHOST_USER_SEND_RARP = 19,
213 VHOST_USER_MAX
214} VhostUserRequest;
215
216typedef struct VhostUserMemoryRegion {
217 uint64_t guest_phys_addr;
218 uint64_t memory_size;
219 uint64_t userspace_addr;
220 uint64_t mmap_offset;
221} VhostUserMemoryRegion;
222
223typedef struct VhostUserMemory {
224 uint32_t nregions;
225 uint32_t padding;
226 VhostUserMemoryRegion regions[VHOST_MEMORY_MAX_NREGIONS];
227} VhostUserMemory;
228
229typedef struct VhostUserLog {
230 uint64_t mmap_size;
231 uint64_t mmap_offset;
232} VhostUserLog;
233
234typedef struct VhostUserMsg {
235 VhostUserRequest request;
236
237#define VHOST_USER_VERSION_MASK (0x3)
238#define VHOST_USER_REPLY_MASK (0x1<<2)
239 uint32_t flags;
240 uint32_t size;
241 union {
242#define VHOST_USER_VRING_IDX_MASK (0xff)
243#define VHOST_USER_VRING_NOFD_MASK (0x1<<8)
244 uint64_t u64;
245 struct vhost_vring_state state;
246 struct vhost_vring_addr addr;
247 VhostUserMemory memory;
248 VhostUserLog log;
249 } payload;
250 int fds[VHOST_MEMORY_MAX_NREGIONS];
251 int fd_num;
252} QEMU_PACKED VhostUserMsg;
253
254#define VHOST_USER_HDR_SIZE offsetof(VhostUserMsg, payload.u64)
255
256
257#define VHOST_USER_VERSION (0x1)
258
259#define MAX_NR_VIRTQUEUE (8)
260
261typedef struct VubrDevRegion {
262
263 uint64_t gpa;
264
265 uint64_t size;
266
267 uint64_t qva;
268
269 uint64_t mmap_offset;
270
271 uint64_t mmap_addr;
272} VubrDevRegion;
273
274typedef struct VubrDev {
275 int sock;
276 Dispatcher dispatcher;
277 uint32_t nregions;
278 VubrDevRegion regions[VHOST_MEMORY_MAX_NREGIONS];
279 VubrVirtq vq[MAX_NR_VIRTQUEUE];
280 int log_call_fd;
281 uint64_t log_size;
282 uint8_t *log_table;
283 int backend_udp_sock;
284 struct sockaddr_in backend_udp_dest;
285 int ready;
286 uint64_t features;
287 int hdrlen;
288} VubrDev;
289
290static const char *vubr_request_str[] = {
291 [VHOST_USER_NONE] = "VHOST_USER_NONE",
292 [VHOST_USER_GET_FEATURES] = "VHOST_USER_GET_FEATURES",
293 [VHOST_USER_SET_FEATURES] = "VHOST_USER_SET_FEATURES",
294 [VHOST_USER_SET_OWNER] = "VHOST_USER_SET_OWNER",
295 [VHOST_USER_RESET_OWNER] = "VHOST_USER_RESET_OWNER",
296 [VHOST_USER_SET_MEM_TABLE] = "VHOST_USER_SET_MEM_TABLE",
297 [VHOST_USER_SET_LOG_BASE] = "VHOST_USER_SET_LOG_BASE",
298 [VHOST_USER_SET_LOG_FD] = "VHOST_USER_SET_LOG_FD",
299 [VHOST_USER_SET_VRING_NUM] = "VHOST_USER_SET_VRING_NUM",
300 [VHOST_USER_SET_VRING_ADDR] = "VHOST_USER_SET_VRING_ADDR",
301 [VHOST_USER_SET_VRING_BASE] = "VHOST_USER_SET_VRING_BASE",
302 [VHOST_USER_GET_VRING_BASE] = "VHOST_USER_GET_VRING_BASE",
303 [VHOST_USER_SET_VRING_KICK] = "VHOST_USER_SET_VRING_KICK",
304 [VHOST_USER_SET_VRING_CALL] = "VHOST_USER_SET_VRING_CALL",
305 [VHOST_USER_SET_VRING_ERR] = "VHOST_USER_SET_VRING_ERR",
306 [VHOST_USER_GET_PROTOCOL_FEATURES] = "VHOST_USER_GET_PROTOCOL_FEATURES",
307 [VHOST_USER_SET_PROTOCOL_FEATURES] = "VHOST_USER_SET_PROTOCOL_FEATURES",
308 [VHOST_USER_GET_QUEUE_NUM] = "VHOST_USER_GET_QUEUE_NUM",
309 [VHOST_USER_SET_VRING_ENABLE] = "VHOST_USER_SET_VRING_ENABLE",
310 [VHOST_USER_SEND_RARP] = "VHOST_USER_SEND_RARP",
311 [VHOST_USER_MAX] = "VHOST_USER_MAX",
312};
313
314static void
315print_buffer(uint8_t *buf, size_t len)
316{
317 int i;
318 printf("Raw buffer:\n");
319 for (i = 0; i < len; i++) {
320 if (i % 16 == 0) {
321 printf("\n");
322 }
323 if (i % 4 == 0) {
324 printf(" ");
325 }
326 printf("%02x ", buf[i]);
327 }
328 printf("\n............................................................\n");
329}
330
331
332static uint64_t
333gpa_to_va(VubrDev *dev, uint64_t guest_addr)
334{
335 int i;
336
337
338 for (i = 0; i < dev->nregions; i++) {
339 VubrDevRegion *r = &dev->regions[i];
340
341 if ((guest_addr >= r->gpa) && (guest_addr < (r->gpa + r->size))) {
342 return guest_addr - r->gpa + r->mmap_addr + r->mmap_offset;
343 }
344 }
345
346 assert(!"address not found in regions");
347 return 0;
348}
349
350
351static uint64_t
352qva_to_va(VubrDev *dev, uint64_t qemu_addr)
353{
354 int i;
355
356
357 for (i = 0; i < dev->nregions; i++) {
358 VubrDevRegion *r = &dev->regions[i];
359
360 if ((qemu_addr >= r->qva) && (qemu_addr < (r->qva + r->size))) {
361 return qemu_addr - r->qva + r->mmap_addr + r->mmap_offset;
362 }
363 }
364
365 assert(!"address not found in regions");
366 return 0;
367}
368
369static void
370vubr_message_read(int conn_fd, VhostUserMsg *vmsg)
371{
372 char control[CMSG_SPACE(VHOST_MEMORY_MAX_NREGIONS * sizeof(int))] = { };
373 struct iovec iov = {
374 .iov_base = (char *)vmsg,
375 .iov_len = VHOST_USER_HDR_SIZE,
376 };
377 struct msghdr msg = {
378 .msg_iov = &iov,
379 .msg_iovlen = 1,
380 .msg_control = control,
381 .msg_controllen = sizeof(control),
382 };
383 size_t fd_size;
384 struct cmsghdr *cmsg;
385 int rc;
386
387 rc = recvmsg(conn_fd, &msg, 0);
388
389 if (rc == 0) {
390 vubr_die("recvmsg");
391 fprintf(stderr, "Peer disconnected.\n");
392 exit(1);
393 }
394 if (rc < 0) {
395 vubr_die("recvmsg");
396 }
397
398 vmsg->fd_num = 0;
399 for (cmsg = CMSG_FIRSTHDR(&msg);
400 cmsg != NULL;
401 cmsg = CMSG_NXTHDR(&msg, cmsg))
402 {
403 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
404 fd_size = cmsg->cmsg_len - CMSG_LEN(0);
405 vmsg->fd_num = fd_size / sizeof(int);
406 memcpy(vmsg->fds, CMSG_DATA(cmsg), fd_size);
407 break;
408 }
409 }
410
411 if (vmsg->size > sizeof(vmsg->payload)) {
412 fprintf(stderr,
413 "Error: too big message request: %d, size: vmsg->size: %u, "
414 "while sizeof(vmsg->payload) = %zu\n",
415 vmsg->request, vmsg->size, sizeof(vmsg->payload));
416 exit(1);
417 }
418
419 if (vmsg->size) {
420 rc = read(conn_fd, &vmsg->payload, vmsg->size);
421 if (rc == 0) {
422 vubr_die("recvmsg");
423 fprintf(stderr, "Peer disconnected.\n");
424 exit(1);
425 }
426 if (rc < 0) {
427 vubr_die("recvmsg");
428 }
429
430 assert(rc == vmsg->size);
431 }
432}
433
434static void
435vubr_message_write(int conn_fd, VhostUserMsg *vmsg)
436{
437 int rc;
438
439 do {
440 rc = write(conn_fd, vmsg, VHOST_USER_HDR_SIZE + vmsg->size);
441 } while (rc < 0 && errno == EINTR);
442
443 if (rc < 0) {
444 vubr_die("write");
445 }
446}
447
448static void
449vubr_backend_udp_sendbuf(VubrDev *dev, uint8_t *buf, size_t len)
450{
451 int slen = sizeof(struct sockaddr_in);
452
453 if (sendto(dev->backend_udp_sock, buf, len, 0,
454 (struct sockaddr *) &dev->backend_udp_dest, slen) == -1) {
455 vubr_die("sendto()");
456 }
457}
458
459static int
460vubr_backend_udp_recvbuf(VubrDev *dev, uint8_t *buf, size_t buflen)
461{
462 int slen = sizeof(struct sockaddr_in);
463 int rc;
464
465 rc = recvfrom(dev->backend_udp_sock, buf, buflen, 0,
466 (struct sockaddr *) &dev->backend_udp_dest,
467 (socklen_t *)&slen);
468 if (rc == -1) {
469 vubr_die("recvfrom()");
470 }
471
472 return rc;
473}
474
475static void
476vubr_consume_raw_packet(VubrDev *dev, uint8_t *buf, uint32_t len)
477{
478 int hdrlen = dev->hdrlen;
479 DPRINT(" hdrlen = %d\n", dev->hdrlen);
480
481 if (VHOST_USER_BRIDGE_DEBUG) {
482 print_buffer(buf, len);
483 }
484 vubr_backend_udp_sendbuf(dev, buf + hdrlen, len - hdrlen);
485}
486
487
488static void
489vubr_log_kick(VubrDev *dev)
490{
491 if (dev->log_call_fd != -1) {
492 DPRINT("Kicking the QEMU's log...\n");
493 eventfd_write(dev->log_call_fd, 1);
494 }
495}
496
497
498static void
499vubr_virtqueue_kick(VubrVirtq *vq)
500{
501 if (!(vq->avail->flags & VRING_AVAIL_F_NO_INTERRUPT)) {
502 DPRINT("Kicking the guest...\n");
503 eventfd_write(vq->call_fd, 1);
504 }
505}
506
507static void
508vubr_log_page(uint8_t *log_table, uint64_t page)
509{
510 DPRINT("Logged dirty guest page: %"PRId64"\n", page);
511 atomic_or(&log_table[page / 8], 1 << (page % 8));
512}
513
514static void
515vubr_log_write(VubrDev *dev, uint64_t address, uint64_t length)
516{
517 uint64_t page;
518
519 if (!(dev->features & (1ULL << VHOST_F_LOG_ALL)) ||
520 !dev->log_table || !length) {
521 return;
522 }
523
524 assert(dev->log_size > ((address + length - 1) / VHOST_LOG_PAGE / 8));
525
526 page = address / VHOST_LOG_PAGE;
527 while (page * VHOST_LOG_PAGE < address + length) {
528 vubr_log_page(dev->log_table, page);
529 page += VHOST_LOG_PAGE;
530 }
531 vubr_log_kick(dev);
532}
533
534static void
535vubr_post_buffer(VubrDev *dev, VubrVirtq *vq, uint8_t *buf, int32_t len)
536{
537 struct vring_desc *desc = vq->desc;
538 struct vring_avail *avail = vq->avail;
539 struct vring_used *used = vq->used;
540 uint64_t log_guest_addr = vq->log_guest_addr;
541 int32_t remaining_len = len;
542
543 unsigned int size = vq->size;
544
545 uint16_t avail_index = atomic_mb_read(&avail->idx);
546
547
548
549
550 assert(vq->last_avail_index != avail_index);
551 uint16_t a_index = vq->last_avail_index % size;
552 uint16_t u_index = vq->last_used_index % size;
553 uint16_t d_index = avail->ring[a_index];
554
555 int i = d_index;
556 uint32_t written_len = 0;
557
558 do {
559 DPRINT("Post packet to guest on vq:\n");
560 DPRINT(" size = %d\n", vq->size);
561 DPRINT(" last_avail_index = %d\n", vq->last_avail_index);
562 DPRINT(" last_used_index = %d\n", vq->last_used_index);
563 DPRINT(" a_index = %d\n", a_index);
564 DPRINT(" u_index = %d\n", u_index);
565 DPRINT(" d_index = %d\n", d_index);
566 DPRINT(" desc[%d].addr = 0x%016"PRIx64"\n", i, desc[i].addr);
567 DPRINT(" desc[%d].len = %d\n", i, desc[i].len);
568 DPRINT(" desc[%d].flags = %d\n", i, desc[i].flags);
569 DPRINT(" avail->idx = %d\n", avail_index);
570 DPRINT(" used->idx = %d\n", used->idx);
571
572 if (!(desc[i].flags & VRING_DESC_F_WRITE)) {
573
574 fprintf(stderr, "Error: descriptor is not writable. Exiting.\n");
575 exit(1);
576 }
577
578 void *chunk_start = (void *)(uintptr_t)gpa_to_va(dev, desc[i].addr);
579 uint32_t chunk_len = desc[i].len;
580 uint32_t chunk_write_len = MIN(remaining_len, chunk_len);
581
582 memcpy(chunk_start, buf + written_len, chunk_write_len);
583 vubr_log_write(dev, desc[i].addr, chunk_write_len);
584 remaining_len -= chunk_write_len;
585 written_len += chunk_write_len;
586
587 if ((remaining_len == 0) || !(desc[i].flags & VRING_DESC_F_NEXT)) {
588 break;
589 }
590
591 i = desc[i].next;
592 } while (1);
593
594 if (remaining_len > 0) {
595 fprintf(stderr,
596 "Too long packet for RX, remaining_len = %d, Dropping...\n",
597 remaining_len);
598 return;
599 }
600
601
602 used->ring[u_index].id = d_index;
603 used->ring[u_index].len = len;
604 vubr_log_write(dev,
605 log_guest_addr + offsetof(struct vring_used, ring[u_index]),
606 sizeof(used->ring[u_index]));
607
608 vq->last_avail_index++;
609 vq->last_used_index++;
610
611 atomic_mb_set(&used->idx, vq->last_used_index);
612 vubr_log_write(dev,
613 log_guest_addr + offsetof(struct vring_used, idx),
614 sizeof(used->idx));
615
616
617 vubr_virtqueue_kick(vq);
618}
619
620static int
621vubr_process_desc(VubrDev *dev, VubrVirtq *vq)
622{
623 struct vring_desc *desc = vq->desc;
624 struct vring_avail *avail = vq->avail;
625 struct vring_used *used = vq->used;
626 uint64_t log_guest_addr = vq->log_guest_addr;
627
628 unsigned int size = vq->size;
629
630 uint16_t a_index = vq->last_avail_index % size;
631 uint16_t u_index = vq->last_used_index % size;
632 uint16_t d_index = avail->ring[a_index];
633
634 uint32_t i, len = 0;
635 size_t buf_size = 4096;
636 uint8_t buf[4096];
637
638 DPRINT("Chunks: ");
639 i = d_index;
640 do {
641 void *chunk_start = (void *)(uintptr_t)gpa_to_va(dev, desc[i].addr);
642 uint32_t chunk_len = desc[i].len;
643
644 assert(!(desc[i].flags & VRING_DESC_F_WRITE));
645
646 if (len + chunk_len < buf_size) {
647 memcpy(buf + len, chunk_start, chunk_len);
648 DPRINT("%d ", chunk_len);
649 } else {
650 fprintf(stderr, "Error: too long packet. Dropping...\n");
651 break;
652 }
653
654 len += chunk_len;
655
656 if (!(desc[i].flags & VRING_DESC_F_NEXT)) {
657 break;
658 }
659
660 i = desc[i].next;
661 } while (1);
662 DPRINT("\n");
663
664 if (!len) {
665 return -1;
666 }
667
668
669 used->ring[u_index].id = d_index;
670 used->ring[u_index].len = len;
671 vubr_log_write(dev,
672 log_guest_addr + offsetof(struct vring_used, ring[u_index]),
673 sizeof(used->ring[u_index]));
674
675 vubr_consume_raw_packet(dev, buf, len);
676
677 return 0;
678}
679
680static void
681vubr_process_avail(VubrDev *dev, VubrVirtq *vq)
682{
683 struct vring_avail *avail = vq->avail;
684 struct vring_used *used = vq->used;
685 uint64_t log_guest_addr = vq->log_guest_addr;
686
687 while (vq->last_avail_index != atomic_mb_read(&avail->idx)) {
688 vubr_process_desc(dev, vq);
689 vq->last_avail_index++;
690 vq->last_used_index++;
691 }
692
693 atomic_mb_set(&used->idx, vq->last_used_index);
694 vubr_log_write(dev,
695 log_guest_addr + offsetof(struct vring_used, idx),
696 sizeof(used->idx));
697}
698
699static void
700vubr_backend_recv_cb(int sock, void *ctx)
701{
702 VubrDev *dev = (VubrDev *) ctx;
703 VubrVirtq *rx_vq = &dev->vq[0];
704 uint8_t buf[4096];
705 struct virtio_net_hdr_v1 *hdr = (struct virtio_net_hdr_v1 *)buf;
706 int hdrlen = dev->hdrlen;
707 int buflen = sizeof(buf);
708 int len;
709
710 if (!dev->ready) {
711 return;
712 }
713
714 DPRINT("\n\n *** IN UDP RECEIVE CALLBACK ***\n\n");
715 DPRINT(" hdrlen = %d\n", hdrlen);
716
717 uint16_t avail_index = atomic_mb_read(&rx_vq->avail->idx);
718
719
720
721
722 if (rx_vq->last_avail_index == avail_index) {
723 DPRINT("Got UDP packet, but no available descriptors on RX virtq.\n");
724 return;
725 }
726
727 memset(buf, 0, hdrlen);
728
729 if (hdrlen == 12)
730 hdr->num_buffers = 1;
731 len = vubr_backend_udp_recvbuf(dev, buf + hdrlen, buflen - hdrlen);
732
733 vubr_post_buffer(dev, rx_vq, buf, len + hdrlen);
734}
735
736static void
737vubr_kick_cb(int sock, void *ctx)
738{
739 VubrDev *dev = (VubrDev *) ctx;
740 eventfd_t kick_data;
741 ssize_t rc;
742
743 rc = eventfd_read(sock, &kick_data);
744 if (rc == -1) {
745 vubr_die("eventfd_read()");
746 } else {
747 DPRINT("Got kick_data: %016"PRIx64"\n", kick_data);
748 vubr_process_avail(dev, &dev->vq[1]);
749 }
750}
751
752static int
753vubr_none_exec(VubrDev *dev, VhostUserMsg *vmsg)
754{
755 DPRINT("Function %s() not implemented yet.\n", __func__);
756 return 0;
757}
758
759static int
760vubr_get_features_exec(VubrDev *dev, VhostUserMsg *vmsg)
761{
762 vmsg->payload.u64 =
763 ((1ULL << VIRTIO_NET_F_MRG_RXBUF) |
764 (1ULL << VHOST_F_LOG_ALL) |
765 (1ULL << VIRTIO_NET_F_GUEST_ANNOUNCE) |
766 (1ULL << VHOST_USER_F_PROTOCOL_FEATURES));
767
768 vmsg->size = sizeof(vmsg->payload.u64);
769
770 DPRINT("Sending back to guest u64: 0x%016"PRIx64"\n", vmsg->payload.u64);
771
772
773 return 1;
774}
775
776static int
777vubr_set_features_exec(VubrDev *dev, VhostUserMsg *vmsg)
778{
779 DPRINT("u64: 0x%016"PRIx64"\n", vmsg->payload.u64);
780
781 dev->features = vmsg->payload.u64;
782 if ((dev->features & (1ULL << VIRTIO_F_VERSION_1)) ||
783 (dev->features & (1ULL << VIRTIO_NET_F_MRG_RXBUF))) {
784 dev->hdrlen = 12;
785 } else {
786 dev->hdrlen = 10;
787 }
788
789 return 0;
790}
791
792static int
793vubr_set_owner_exec(VubrDev *dev, VhostUserMsg *vmsg)
794{
795 return 0;
796}
797
798static void
799vubr_close_log(VubrDev *dev)
800{
801 if (dev->log_table) {
802 if (munmap(dev->log_table, dev->log_size) != 0) {
803 vubr_die("munmap()");
804 }
805
806 dev->log_table = 0;
807 }
808 if (dev->log_call_fd != -1) {
809 close(dev->log_call_fd);
810 dev->log_call_fd = -1;
811 }
812}
813
814static int
815vubr_reset_device_exec(VubrDev *dev, VhostUserMsg *vmsg)
816{
817 vubr_close_log(dev);
818 dev->ready = 0;
819 dev->features = 0;
820 return 0;
821}
822
823static int
824vubr_set_mem_table_exec(VubrDev *dev, VhostUserMsg *vmsg)
825{
826 int i;
827 VhostUserMemory *memory = &vmsg->payload.memory;
828 dev->nregions = memory->nregions;
829
830 DPRINT("Nregions: %d\n", memory->nregions);
831 for (i = 0; i < dev->nregions; i++) {
832 void *mmap_addr;
833 VhostUserMemoryRegion *msg_region = &memory->regions[i];
834 VubrDevRegion *dev_region = &dev->regions[i];
835
836 DPRINT("Region %d\n", i);
837 DPRINT(" guest_phys_addr: 0x%016"PRIx64"\n",
838 msg_region->guest_phys_addr);
839 DPRINT(" memory_size: 0x%016"PRIx64"\n",
840 msg_region->memory_size);
841 DPRINT(" userspace_addr 0x%016"PRIx64"\n",
842 msg_region->userspace_addr);
843 DPRINT(" mmap_offset 0x%016"PRIx64"\n",
844 msg_region->mmap_offset);
845
846 dev_region->gpa = msg_region->guest_phys_addr;
847 dev_region->size = msg_region->memory_size;
848 dev_region->qva = msg_region->userspace_addr;
849 dev_region->mmap_offset = msg_region->mmap_offset;
850
851
852
853
854 mmap_addr = mmap(0, dev_region->size + dev_region->mmap_offset,
855 PROT_READ | PROT_WRITE, MAP_SHARED,
856 vmsg->fds[i], 0);
857
858 if (mmap_addr == MAP_FAILED) {
859 vubr_die("mmap");
860 }
861 dev_region->mmap_addr = (uint64_t)(uintptr_t)mmap_addr;
862 DPRINT(" mmap_addr: 0x%016"PRIx64"\n", dev_region->mmap_addr);
863
864 close(vmsg->fds[i]);
865 }
866
867 return 0;
868}
869
870static int
871vubr_set_log_base_exec(VubrDev *dev, VhostUserMsg *vmsg)
872{
873 int fd;
874 uint64_t log_mmap_size, log_mmap_offset;
875 void *rc;
876
877 assert(vmsg->fd_num == 1);
878 fd = vmsg->fds[0];
879
880 assert(vmsg->size == sizeof(vmsg->payload.log));
881 log_mmap_offset = vmsg->payload.log.mmap_offset;
882 log_mmap_size = vmsg->payload.log.mmap_size;
883 DPRINT("Log mmap_offset: %"PRId64"\n", log_mmap_offset);
884 DPRINT("Log mmap_size: %"PRId64"\n", log_mmap_size);
885
886 rc = mmap(0, log_mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd,
887 log_mmap_offset);
888 if (rc == MAP_FAILED) {
889 vubr_die("mmap");
890 }
891 dev->log_table = rc;
892 dev->log_size = log_mmap_size;
893
894 vmsg->size = sizeof(vmsg->payload.u64);
895
896 return 1;
897}
898
899static int
900vubr_set_log_fd_exec(VubrDev *dev, VhostUserMsg *vmsg)
901{
902 assert(vmsg->fd_num == 1);
903 dev->log_call_fd = vmsg->fds[0];
904 DPRINT("Got log_call_fd: %d\n", vmsg->fds[0]);
905 return 0;
906}
907
908static int
909vubr_set_vring_num_exec(VubrDev *dev, VhostUserMsg *vmsg)
910{
911 unsigned int index = vmsg->payload.state.index;
912 unsigned int num = vmsg->payload.state.num;
913
914 DPRINT("State.index: %d\n", index);
915 DPRINT("State.num: %d\n", num);
916 dev->vq[index].size = num;
917 return 0;
918}
919
920static int
921vubr_set_vring_addr_exec(VubrDev *dev, VhostUserMsg *vmsg)
922{
923 struct vhost_vring_addr *vra = &vmsg->payload.addr;
924 unsigned int index = vra->index;
925 VubrVirtq *vq = &dev->vq[index];
926
927 DPRINT("vhost_vring_addr:\n");
928 DPRINT(" index: %d\n", vra->index);
929 DPRINT(" flags: %d\n", vra->flags);
930 DPRINT(" desc_user_addr: 0x%016llx\n", vra->desc_user_addr);
931 DPRINT(" used_user_addr: 0x%016llx\n", vra->used_user_addr);
932 DPRINT(" avail_user_addr: 0x%016llx\n", vra->avail_user_addr);
933 DPRINT(" log_guest_addr: 0x%016llx\n", vra->log_guest_addr);
934
935 vq->desc = (struct vring_desc *)(uintptr_t)qva_to_va(dev, vra->desc_user_addr);
936 vq->used = (struct vring_used *)(uintptr_t)qva_to_va(dev, vra->used_user_addr);
937 vq->avail = (struct vring_avail *)(uintptr_t)qva_to_va(dev, vra->avail_user_addr);
938 vq->log_guest_addr = vra->log_guest_addr;
939
940 DPRINT("Setting virtq addresses:\n");
941 DPRINT(" vring_desc at %p\n", vq->desc);
942 DPRINT(" vring_used at %p\n", vq->used);
943 DPRINT(" vring_avail at %p\n", vq->avail);
944
945 vq->last_used_index = vq->used->idx;
946
947 if (vq->last_avail_index != vq->used->idx) {
948 DPRINT("Last avail index != used index: %d != %d, resuming",
949 vq->last_avail_index, vq->used->idx);
950 vq->last_avail_index = vq->used->idx;
951 }
952
953 return 0;
954}
955
956static int
957vubr_set_vring_base_exec(VubrDev *dev, VhostUserMsg *vmsg)
958{
959 unsigned int index = vmsg->payload.state.index;
960 unsigned int num = vmsg->payload.state.num;
961
962 DPRINT("State.index: %d\n", index);
963 DPRINT("State.num: %d\n", num);
964 dev->vq[index].last_avail_index = num;
965
966 return 0;
967}
968
969static int
970vubr_get_vring_base_exec(VubrDev *dev, VhostUserMsg *vmsg)
971{
972 unsigned int index = vmsg->payload.state.index;
973
974 DPRINT("State.index: %d\n", index);
975 vmsg->payload.state.num = dev->vq[index].last_avail_index;
976 vmsg->size = sizeof(vmsg->payload.state);
977
978
979
980 dev->ready = 0;
981
982 if (dev->vq[index].call_fd != -1) {
983 close(dev->vq[index].call_fd);
984 dispatcher_remove(&dev->dispatcher, dev->vq[index].call_fd);
985 dev->vq[index].call_fd = -1;
986 }
987 if (dev->vq[index].kick_fd != -1) {
988 close(dev->vq[index].kick_fd);
989 dispatcher_remove(&dev->dispatcher, dev->vq[index].kick_fd);
990 dev->vq[index].kick_fd = -1;
991 }
992
993
994 return 1;
995}
996
997static int
998vubr_set_vring_kick_exec(VubrDev *dev, VhostUserMsg *vmsg)
999{
1000 uint64_t u64_arg = vmsg->payload.u64;
1001 int index = u64_arg & VHOST_USER_VRING_IDX_MASK;
1002
1003 DPRINT("u64: 0x%016"PRIx64"\n", vmsg->payload.u64);
1004
1005 assert((u64_arg & VHOST_USER_VRING_NOFD_MASK) == 0);
1006 assert(vmsg->fd_num == 1);
1007
1008 if (dev->vq[index].kick_fd != -1) {
1009 close(dev->vq[index].kick_fd);
1010 dispatcher_remove(&dev->dispatcher, dev->vq[index].kick_fd);
1011 }
1012 dev->vq[index].kick_fd = vmsg->fds[0];
1013 DPRINT("Got kick_fd: %d for vq: %d\n", vmsg->fds[0], index);
1014
1015 if (index % 2 == 1) {
1016
1017 dispatcher_add(&dev->dispatcher, dev->vq[index].kick_fd,
1018 dev, vubr_kick_cb);
1019
1020 DPRINT("Waiting for kicks on fd: %d for vq: %d\n",
1021 dev->vq[index].kick_fd, index);
1022 }
1023
1024
1025
1026
1027 if (dev->vq[0].kick_fd != -1 &&
1028 dev->vq[1].kick_fd != -1) {
1029 dev->ready = 1;
1030 DPRINT("vhost-user-bridge is ready for processing queues.\n");
1031 }
1032 return 0;
1033
1034}
1035
1036static int
1037vubr_set_vring_call_exec(VubrDev *dev, VhostUserMsg *vmsg)
1038{
1039 uint64_t u64_arg = vmsg->payload.u64;
1040 int index = u64_arg & VHOST_USER_VRING_IDX_MASK;
1041
1042 DPRINT("u64: 0x%016"PRIx64"\n", vmsg->payload.u64);
1043 assert((u64_arg & VHOST_USER_VRING_NOFD_MASK) == 0);
1044 assert(vmsg->fd_num == 1);
1045
1046 if (dev->vq[index].call_fd != -1) {
1047 close(dev->vq[index].call_fd);
1048 dispatcher_remove(&dev->dispatcher, dev->vq[index].call_fd);
1049 }
1050 dev->vq[index].call_fd = vmsg->fds[0];
1051 DPRINT("Got call_fd: %d for vq: %d\n", vmsg->fds[0], index);
1052
1053 return 0;
1054}
1055
1056static int
1057vubr_set_vring_err_exec(VubrDev *dev, VhostUserMsg *vmsg)
1058{
1059 DPRINT("u64: 0x%016"PRIx64"\n", vmsg->payload.u64);
1060 return 0;
1061}
1062
1063static int
1064vubr_get_protocol_features_exec(VubrDev *dev, VhostUserMsg *vmsg)
1065{
1066 vmsg->payload.u64 = 1ULL << VHOST_USER_PROTOCOL_F_LOG_SHMFD;
1067 DPRINT("u64: 0x%016"PRIx64"\n", vmsg->payload.u64);
1068 vmsg->size = sizeof(vmsg->payload.u64);
1069
1070
1071 return 1;
1072}
1073
1074static int
1075vubr_set_protocol_features_exec(VubrDev *dev, VhostUserMsg *vmsg)
1076{
1077
1078 DPRINT("u64: 0x%016"PRIx64"\n", vmsg->payload.u64);
1079 return 0;
1080}
1081
1082static int
1083vubr_get_queue_num_exec(VubrDev *dev, VhostUserMsg *vmsg)
1084{
1085 DPRINT("Function %s() not implemented yet.\n", __func__);
1086 return 0;
1087}
1088
1089static int
1090vubr_set_vring_enable_exec(VubrDev *dev, VhostUserMsg *vmsg)
1091{
1092 unsigned int index = vmsg->payload.state.index;
1093 unsigned int enable = vmsg->payload.state.num;
1094
1095 DPRINT("State.index: %d\n", index);
1096 DPRINT("State.enable: %d\n", enable);
1097 dev->vq[index].enable = enable;
1098 return 0;
1099}
1100
1101static int
1102vubr_send_rarp_exec(VubrDev *dev, VhostUserMsg *vmsg)
1103{
1104 DPRINT("Function %s() not implemented yet.\n", __func__);
1105 return 0;
1106}
1107
1108static int
1109vubr_execute_request(VubrDev *dev, VhostUserMsg *vmsg)
1110{
1111
1112 DPRINT(
1113 "================== Vhost user message from QEMU ==================\n");
1114 DPRINT("Request: %s (%d)\n", vubr_request_str[vmsg->request],
1115 vmsg->request);
1116 DPRINT("Flags: 0x%x\n", vmsg->flags);
1117 DPRINT("Size: %d\n", vmsg->size);
1118
1119 if (vmsg->fd_num) {
1120 int i;
1121 DPRINT("Fds:");
1122 for (i = 0; i < vmsg->fd_num; i++) {
1123 DPRINT(" %d", vmsg->fds[i]);
1124 }
1125 DPRINT("\n");
1126 }
1127
1128 switch (vmsg->request) {
1129 case VHOST_USER_NONE:
1130 return vubr_none_exec(dev, vmsg);
1131 case VHOST_USER_GET_FEATURES:
1132 return vubr_get_features_exec(dev, vmsg);
1133 case VHOST_USER_SET_FEATURES:
1134 return vubr_set_features_exec(dev, vmsg);
1135 case VHOST_USER_SET_OWNER:
1136 return vubr_set_owner_exec(dev, vmsg);
1137 case VHOST_USER_RESET_OWNER:
1138 return vubr_reset_device_exec(dev, vmsg);
1139 case VHOST_USER_SET_MEM_TABLE:
1140 return vubr_set_mem_table_exec(dev, vmsg);
1141 case VHOST_USER_SET_LOG_BASE:
1142 return vubr_set_log_base_exec(dev, vmsg);
1143 case VHOST_USER_SET_LOG_FD:
1144 return vubr_set_log_fd_exec(dev, vmsg);
1145 case VHOST_USER_SET_VRING_NUM:
1146 return vubr_set_vring_num_exec(dev, vmsg);
1147 case VHOST_USER_SET_VRING_ADDR:
1148 return vubr_set_vring_addr_exec(dev, vmsg);
1149 case VHOST_USER_SET_VRING_BASE:
1150 return vubr_set_vring_base_exec(dev, vmsg);
1151 case VHOST_USER_GET_VRING_BASE:
1152 return vubr_get_vring_base_exec(dev, vmsg);
1153 case VHOST_USER_SET_VRING_KICK:
1154 return vubr_set_vring_kick_exec(dev, vmsg);
1155 case VHOST_USER_SET_VRING_CALL:
1156 return vubr_set_vring_call_exec(dev, vmsg);
1157 case VHOST_USER_SET_VRING_ERR:
1158 return vubr_set_vring_err_exec(dev, vmsg);
1159 case VHOST_USER_GET_PROTOCOL_FEATURES:
1160 return vubr_get_protocol_features_exec(dev, vmsg);
1161 case VHOST_USER_SET_PROTOCOL_FEATURES:
1162 return vubr_set_protocol_features_exec(dev, vmsg);
1163 case VHOST_USER_GET_QUEUE_NUM:
1164 return vubr_get_queue_num_exec(dev, vmsg);
1165 case VHOST_USER_SET_VRING_ENABLE:
1166 return vubr_set_vring_enable_exec(dev, vmsg);
1167 case VHOST_USER_SEND_RARP:
1168 return vubr_send_rarp_exec(dev, vmsg);
1169
1170 case VHOST_USER_MAX:
1171 assert(vmsg->request != VHOST_USER_MAX);
1172 }
1173 return 0;
1174}
1175
1176static void
1177vubr_receive_cb(int sock, void *ctx)
1178{
1179 VubrDev *dev = (VubrDev *) ctx;
1180 VhostUserMsg vmsg;
1181 int reply_requested;
1182
1183 vubr_message_read(sock, &vmsg);
1184 reply_requested = vubr_execute_request(dev, &vmsg);
1185 if (reply_requested) {
1186
1187 vmsg.flags &= ~VHOST_USER_VERSION_MASK;
1188 vmsg.flags |= VHOST_USER_VERSION;
1189 vmsg.flags |= VHOST_USER_REPLY_MASK;
1190 vubr_message_write(sock, &vmsg);
1191 }
1192}
1193
1194static void
1195vubr_accept_cb(int sock, void *ctx)
1196{
1197 VubrDev *dev = (VubrDev *)ctx;
1198 int conn_fd;
1199 struct sockaddr_un un;
1200 socklen_t len = sizeof(un);
1201
1202 conn_fd = accept(sock, (struct sockaddr *) &un, &len);
1203 if (conn_fd == -1) {
1204 vubr_die("accept()");
1205 }
1206 DPRINT("Got connection from remote peer on sock %d\n", conn_fd);
1207 dispatcher_add(&dev->dispatcher, conn_fd, ctx, vubr_receive_cb);
1208}
1209
1210static VubrDev *
1211vubr_new(const char *path, bool client)
1212{
1213 VubrDev *dev = (VubrDev *) calloc(1, sizeof(VubrDev));
1214 dev->nregions = 0;
1215 int i;
1216 struct sockaddr_un un;
1217 CallbackFunc cb;
1218 size_t len;
1219
1220 for (i = 0; i < MAX_NR_VIRTQUEUE; i++) {
1221 dev->vq[i] = (VubrVirtq) {
1222 .call_fd = -1, .kick_fd = -1,
1223 .size = 0,
1224 .last_avail_index = 0, .last_used_index = 0,
1225 .desc = 0, .avail = 0, .used = 0,
1226 .enable = 0,
1227 };
1228 }
1229
1230
1231 dev->log_call_fd = -1;
1232 dev->log_size = 0;
1233 dev->log_table = 0;
1234 dev->ready = 0;
1235 dev->features = 0;
1236
1237
1238 dev->sock = socket(AF_UNIX, SOCK_STREAM, 0);
1239 if (dev->sock == -1) {
1240 vubr_die("socket");
1241 }
1242
1243 un.sun_family = AF_UNIX;
1244 strcpy(un.sun_path, path);
1245 len = sizeof(un.sun_family) + strlen(path);
1246
1247 if (!client) {
1248 unlink(path);
1249
1250 if (bind(dev->sock, (struct sockaddr *) &un, len) == -1) {
1251 vubr_die("bind");
1252 }
1253
1254 if (listen(dev->sock, 1) == -1) {
1255 vubr_die("listen");
1256 }
1257 cb = vubr_accept_cb;
1258
1259 DPRINT("Waiting for connections on UNIX socket %s ...\n", path);
1260 } else {
1261 if (connect(dev->sock, (struct sockaddr *)&un, len) == -1) {
1262 vubr_die("connect");
1263 }
1264 cb = vubr_receive_cb;
1265 }
1266
1267 dispatcher_init(&dev->dispatcher);
1268 dispatcher_add(&dev->dispatcher, dev->sock, (void *)dev, cb);
1269
1270 return dev;
1271}
1272
1273static void
1274vubr_set_host(struct sockaddr_in *saddr, const char *host)
1275{
1276 if (isdigit(host[0])) {
1277 if (!inet_aton(host, &saddr->sin_addr)) {
1278 fprintf(stderr, "inet_aton() failed.\n");
1279 exit(1);
1280 }
1281 } else {
1282 struct hostent *he = gethostbyname(host);
1283
1284 if (!he) {
1285 fprintf(stderr, "gethostbyname() failed.\n");
1286 exit(1);
1287 }
1288 saddr->sin_addr = *(struct in_addr *)he->h_addr;
1289 }
1290}
1291
1292static void
1293vubr_backend_udp_setup(VubrDev *dev,
1294 const char *local_host,
1295 const char *local_port,
1296 const char *remote_host,
1297 const char *remote_port)
1298{
1299 int sock;
1300 const char *r;
1301
1302 int lport, rport;
1303
1304 lport = strtol(local_port, (char **)&r, 0);
1305 if (r == local_port) {
1306 fprintf(stderr, "lport parsing failed.\n");
1307 exit(1);
1308 }
1309
1310 rport = strtol(remote_port, (char **)&r, 0);
1311 if (r == remote_port) {
1312 fprintf(stderr, "rport parsing failed.\n");
1313 exit(1);
1314 }
1315
1316 struct sockaddr_in si_local = {
1317 .sin_family = AF_INET,
1318 .sin_port = htons(lport),
1319 };
1320
1321 vubr_set_host(&si_local, local_host);
1322
1323
1324 dev->backend_udp_dest = (struct sockaddr_in) {
1325 .sin_family = AF_INET,
1326 .sin_port = htons(rport),
1327 };
1328 vubr_set_host(&dev->backend_udp_dest, remote_host);
1329
1330 sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
1331 if (sock == -1) {
1332 vubr_die("socket");
1333 }
1334
1335 if (bind(sock, (struct sockaddr *)&si_local, sizeof(si_local)) == -1) {
1336 vubr_die("bind");
1337 }
1338
1339 dev->backend_udp_sock = sock;
1340 dispatcher_add(&dev->dispatcher, sock, dev, vubr_backend_recv_cb);
1341 DPRINT("Waiting for data from udp backend on %s:%d...\n",
1342 local_host, lport);
1343}
1344
1345static void
1346vubr_run(VubrDev *dev)
1347{
1348 while (1) {
1349
1350 dispatcher_wait(&dev->dispatcher, 200000);
1351
1352 }
1353}
1354
1355static int
1356vubr_parse_host_port(const char **host, const char **port, const char *buf)
1357{
1358 char *p = strchr(buf, ':');
1359
1360 if (!p) {
1361 return -1;
1362 }
1363 *p = '\0';
1364 *host = strdup(buf);
1365 *port = strdup(p + 1);
1366 return 0;
1367}
1368
1369#define DEFAULT_UD_SOCKET "/tmp/vubr.sock"
1370#define DEFAULT_LHOST "127.0.0.1"
1371#define DEFAULT_LPORT "4444"
1372#define DEFAULT_RHOST "127.0.0.1"
1373#define DEFAULT_RPORT "5555"
1374
1375static const char *ud_socket_path = DEFAULT_UD_SOCKET;
1376static const char *lhost = DEFAULT_LHOST;
1377static const char *lport = DEFAULT_LPORT;
1378static const char *rhost = DEFAULT_RHOST;
1379static const char *rport = DEFAULT_RPORT;
1380
1381int
1382main(int argc, char *argv[])
1383{
1384 VubrDev *dev;
1385 int opt;
1386 bool client = false;
1387
1388 while ((opt = getopt(argc, argv, "l:r:u:c")) != -1) {
1389
1390 switch (opt) {
1391 case 'l':
1392 if (vubr_parse_host_port(&lhost, &lport, optarg) < 0) {
1393 goto out;
1394 }
1395 break;
1396 case 'r':
1397 if (vubr_parse_host_port(&rhost, &rport, optarg) < 0) {
1398 goto out;
1399 }
1400 break;
1401 case 'u':
1402 ud_socket_path = strdup(optarg);
1403 break;
1404 case 'c':
1405 client = true;
1406 break;
1407 default:
1408 goto out;
1409 }
1410 }
1411
1412 DPRINT("ud socket: %s (%s)\n", ud_socket_path,
1413 client ? "client" : "server");
1414 DPRINT("local: %s:%s\n", lhost, lport);
1415 DPRINT("remote: %s:%s\n", rhost, rport);
1416
1417 dev = vubr_new(ud_socket_path, client);
1418 if (!dev) {
1419 return 1;
1420 }
1421
1422 vubr_backend_udp_setup(dev, lhost, lport, rhost, rport);
1423 vubr_run(dev);
1424 return 0;
1425
1426out:
1427 fprintf(stderr, "Usage: %s ", argv[0]);
1428 fprintf(stderr, "[-c] [-u ud_socket_path] [-l lhost:lport] [-r rhost:rport]\n");
1429 fprintf(stderr, "\t-u path to unix doman socket. default: %s\n",
1430 DEFAULT_UD_SOCKET);
1431 fprintf(stderr, "\t-l local host and port. default: %s:%s\n",
1432 DEFAULT_LHOST, DEFAULT_LPORT);
1433 fprintf(stderr, "\t-r remote host and port. default: %s:%s\n",
1434 DEFAULT_RHOST, DEFAULT_RPORT);
1435 fprintf(stderr, "\t-c client mode\n");
1436
1437 return 1;
1438}
1439
