Revision 5c361cc3

b/Makefile
107 107
net-nested-$(CONFIG_SOLARIS) += tap-solaris.o
108 108
net-nested-$(CONFIG_AIX) += tap-aix.o
109 109
net-nested-$(CONFIG_SLIRP) += slirp.o
110
net-nested-$(CONFIG_VDE) += vde.o
110 111
net-obj-y += $(addprefix net/, $(net-nested-y))
111 112

  
112 113
######################################################################
b/net.c
86 86
#include <util.h>
87 87
#endif
88 88

  
89
#if defined(CONFIG_VDE)
90
#include <libvdeplug.h>
91
#endif
92

  
93 89
#include "qemu-common.h"
94 90
#include "net.h"
95 91
#include "net/tap.h"
96 92
#include "net/slirp.h"
93
#include "net/vde.h"
97 94
#include "monitor.h"
98 95
#include "sysemu.h"
99 96
#include "qemu-timer.h"
......
719 716
    return qemu_sendv_packet_async(vc, iov, iovcnt, NULL);
720 717
}
721 718

  
722
#if defined(CONFIG_VDE)
723
typedef struct VDEState {
724
    VLANClientState *vc;
725
    VDECONN *vde;
726
} VDEState;
727

  
728
static void vde_to_qemu(void *opaque)
729
{
730
    VDEState *s = opaque;
731
    uint8_t buf[4096];
732
    int size;
733

  
734
    size = vde_recv(s->vde, (char *)buf, sizeof(buf), 0);
735
    if (size > 0) {
736
        qemu_send_packet(s->vc, buf, size);
737
    }
738
}
739

  
740
static ssize_t vde_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
741
{
742
    VDEState *s = vc->opaque;
743
    ssize_t ret;
744

  
745
    do {
746
      ret = vde_send(s->vde, (const char *)buf, size, 0);
747
    } while (ret < 0 && errno == EINTR);
748

  
749
    return ret;
750
}
751

  
752
static void vde_cleanup(VLANClientState *vc)
753
{
754
    VDEState *s = vc->opaque;
755
    qemu_set_fd_handler(vde_datafd(s->vde), NULL, NULL, NULL);
756
    vde_close(s->vde);
757
    qemu_free(s);
758
}
759

  
760
static int net_vde_init(VLANState *vlan, const char *model,
761
                        const char *name, const char *sock,
762
                        int port, const char *group, int mode)
763
{
764
    VDEState *s;
765
    char *init_group = (char *)group;
766
    char *init_sock = (char *)sock;
767

  
768
    struct vde_open_args args = {
769
        .port = port,
770
        .group = init_group,
771
        .mode = mode,
772
    };
773

  
774
    s = qemu_mallocz(sizeof(VDEState));
775
    s->vde = vde_open(init_sock, (char *)"QEMU", &args);
776
    if (!s->vde){
777
        free(s);
778
        return -1;
779
    }
780
    s->vc = qemu_new_vlan_client(NET_CLIENT_TYPE_VDE,
781
                                 vlan, NULL, model, name, NULL,
782
                                 vde_receive, NULL, NULL,
783
                                 vde_cleanup, s);
784
    qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s);
785
    snprintf(s->vc->info_str, sizeof(s->vc->info_str), "sock=%s,fd=%d",
786
             sock, vde_datafd(s->vde));
787
    return 0;
788
}
789
#endif
790

  
791 719
/* network connection */
792 720
typedef struct NetSocketState {
793 721
    VLANClientState *vc;
......
1600 1528
    return 0;
1601 1529
}
1602 1530

  
1603
#ifdef CONFIG_VDE
1604
static int net_init_vde(QemuOpts *opts,
1605
                        Monitor *mon,
1606
                        const char *name,
1607
                        VLANState *vlan)
1608
{
1609
    const char *sock;
1610
    const char *group;
1611
    int port, mode;
1612

  
1613
    sock  = qemu_opt_get(opts, "sock");
1614
    group = qemu_opt_get(opts, "group");
1615

  
1616
    port = qemu_opt_get_number(opts, "port", 0);
1617
    mode = qemu_opt_get_number(opts, "mode", 0700);
1618

  
1619
    if (net_vde_init(vlan, "vde", name, sock, port, group, mode) == -1) {
1620
        return -1;
1621
    }
1622

  
1623
    if (vlan) {
1624
        vlan->nb_host_devs++;
1625
    }
1626

  
1627
    return 0;
1628
}
1629
#endif
1630

  
1631 1531
static int net_init_dump(QemuOpts *opts,
1632 1532
                         Monitor *mon,
1633 1533
                         const char *name,
b/net/vde.c
1
/*
2
 * QEMU System Emulator
3
 *
4
 * Copyright (c) 2003-2008 Fabrice Bellard
5
 *
6
 * Permission is hereby granted, free of charge, to any person obtaining a copy
7
 * of this software and associated documentation files (the "Software"), to deal
8
 * in the Software without restriction, including without limitation the rights
9
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10
 * copies of the Software, and to permit persons to whom the Software is
11
 * furnished to do so, subject to the following conditions:
12
 *
13
 * The above copyright notice and this permission notice shall be included in
14
 * all copies or substantial portions of the Software.
15
 *
16
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22
 * THE SOFTWARE.
23
 */
24
#include "net/vde.h"
25

  
26
#include "config-host.h"
27

  
28
#include <libvdeplug.h>
29

  
30
#include "net.h"
31
#include "qemu-char.h"
32
#include "qemu-common.h"
33
#include "qemu-option.h"
34
#include "sysemu.h"
35

  
36
typedef struct VDEState {
37
    VLANClientState *vc;
38
    VDECONN *vde;
39
} VDEState;
40

  
41
static void vde_to_qemu(void *opaque)
42
{
43
    VDEState *s = opaque;
44
    uint8_t buf[4096];
45
    int size;
46

  
47
    size = vde_recv(s->vde, (char *)buf, sizeof(buf), 0);
48
    if (size > 0) {
49
        qemu_send_packet(s->vc, buf, size);
50
    }
51
}
52

  
53
static ssize_t vde_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
54
{
55
    VDEState *s = vc->opaque;
56
    ssize_t ret;
57

  
58
    do {
59
      ret = vde_send(s->vde, (const char *)buf, size, 0);
60
    } while (ret < 0 && errno == EINTR);
61

  
62
    return ret;
63
}
64

  
65
static void vde_cleanup(VLANClientState *vc)
66
{
67
    VDEState *s = vc->opaque;
68
    qemu_set_fd_handler(vde_datafd(s->vde), NULL, NULL, NULL);
69
    vde_close(s->vde);
70
    qemu_free(s);
71
}
72

  
73
static int net_vde_init(VLANState *vlan, const char *model,
74
                        const char *name, const char *sock,
75
                        int port, const char *group, int mode)
76
{
77
    VDEState *s;
78
    char *init_group = (char *)group;
79
    char *init_sock = (char *)sock;
80

  
81
    struct vde_open_args args = {
82
        .port = port,
83
        .group = init_group,
84
        .mode = mode,
85
    };
86

  
87
    s = qemu_mallocz(sizeof(VDEState));
88
    s->vde = vde_open(init_sock, (char *)"QEMU", &args);
89
    if (!s->vde){
90
        free(s);
91
        return -1;
92
    }
93
    s->vc = qemu_new_vlan_client(NET_CLIENT_TYPE_VDE,
94
                                 vlan, NULL, model, name, NULL,
95
                                 vde_receive, NULL, NULL,
96
                                 vde_cleanup, s);
97
    qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s);
98
    snprintf(s->vc->info_str, sizeof(s->vc->info_str), "sock=%s,fd=%d",
99
             sock, vde_datafd(s->vde));
100
    return 0;
101
}
102

  
103
int net_init_vde(QemuOpts *opts, Monitor *mon, const char *name, VLANState *vlan)
104
{
105
    const char *sock;
106
    const char *group;
107
    int port, mode;
108

  
109
    sock  = qemu_opt_get(opts, "sock");
110
    group = qemu_opt_get(opts, "group");
111

  
112
    port = qemu_opt_get_number(opts, "port", 0);
113
    mode = qemu_opt_get_number(opts, "mode", 0700);
114

  
115
    if (net_vde_init(vlan, "vde", name, sock, port, group, mode) == -1) {
116
        return -1;
117
    }
118

  
119
    if (vlan) {
120
        vlan->nb_host_devs++;
121
    }
122

  
123
    return 0;
124
}
b/net/vde.h
1
/*
2
 * QEMU System Emulator
3
 *
4
 * Copyright (c) 2003-2008 Fabrice Bellard
5
 *
6
 * Permission is hereby granted, free of charge, to any person obtaining a copy
7
 * of this software and associated documentation files (the "Software"), to deal
8
 * in the Software without restriction, including without limitation the rights
9
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10
 * copies of the Software, and to permit persons to whom the Software is
11
 * furnished to do so, subject to the following conditions:
12
 *
13
 * The above copyright notice and this permission notice shall be included in
14
 * all copies or substantial portions of the Software.
15
 *
16
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22
 * THE SOFTWARE.
23
 */
24
#ifndef QEMU_NET_VDE_H
25
#define QEMU_NET_VDE_H
26

  
27
#include "qemu-common.h"
28
#include "qemu-option.h"
29

  
30
#ifdef CONFIG_VDE
31

  
32
int net_init_vde(QemuOpts *opts, Monitor *mon, const char *name, VLANState *vlan);
33

  
34
#endif /* CONFIG_VDE */
35

  
36
#endif /* QEMU_NET_VDE_H */

Also available in: Unified diff