* distribution); if not, see <http://www.gnu.org/licenses/>.
*/
-#include "net/tap.h"
+#include "tap_int.h"
#include "qemu-common.h"
-#include "net.h"
-#include "sysemu.h"
+#include "clients.h" /* net_init_tap */
+#include "net/net.h"
+#include "net/tap.h" /* tap_has_ufo, ... */
+#include "sysemu/sysemu.h"
+#include "qemu/error-report.h"
#include <stdio.h>
#include <windows.h>
#include <winioctl.h>
}
}
- return 0;
+ return write_size;
}
static DWORD WINAPI tap_win32_thread_entry(LPVOID param)
}
static int tap_win32_open(tap_win32_overlapped_t **phandle,
- const char *prefered_name)
+ const char *preferred_name)
{
char device_path[256];
char device_guid[0x100];
} version;
DWORD version_len;
DWORD idThread;
- HANDLE hThread;
- if (prefered_name != NULL)
- snprintf(name_buffer, sizeof(name_buffer), "%s", prefered_name);
+ if (preferred_name != NULL) {
+ snprintf(name_buffer, sizeof(name_buffer), "%s", preferred_name);
+ }
rc = get_device_guid(device_guid, sizeof(device_guid), name_buffer, sizeof(name_buffer));
if (rc)
*phandle = &tap_overlapped;
- hThread = CreateThread(NULL, 0, tap_win32_thread_entry,
- (LPVOID)&tap_overlapped, 0, &idThread);
+ CreateThread(NULL, 0, tap_win32_thread_entry,
+ (LPVOID)&tap_overlapped, 0, &idThread);
return 0;
}
/********************************************/
typedef struct TAPState {
- VLANClientState *vc;
+ NetClientState nc;
tap_win32_overlapped_t *handle;
} TAPState;
-static void tap_cleanup(VLANClientState *vc)
+static void tap_cleanup(NetClientState *nc)
{
- TAPState *s = vc->opaque;
+ TAPState *s = DO_UPCAST(TAPState, nc, nc);
qemu_del_wait_object(s->handle->tap_semaphore, NULL, NULL);
/* FIXME: need to kill thread and close file handle:
tap_win32_close(s);
*/
- qemu_free(s);
}
-static ssize_t tap_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
+static ssize_t tap_receive(NetClientState *nc, const uint8_t *buf, size_t size)
{
- TAPState *s = vc->opaque;
+ TAPState *s = DO_UPCAST(TAPState, nc, nc);
return tap_win32_write(s->handle, buf, size);
}
size = tap_win32_read(s->handle, &buf, max_size);
if (size > 0) {
- qemu_send_packet(s->vc, buf, size);
+ qemu_send_packet(&s->nc, buf, size);
tap_win32_free_buffer(s->handle, buf);
}
}
-static int tap_win32_init(VLANState *vlan, const char *model,
+static NetClientInfo net_tap_win32_info = {
+ .type = NET_CLIENT_OPTIONS_KIND_TAP,
+ .size = sizeof(TAPState),
+ .receive = tap_receive,
+ .cleanup = tap_cleanup,
+};
+
+static int tap_win32_init(NetClientState *peer, const char *model,
const char *name, const char *ifname)
{
+ NetClientState *nc;
TAPState *s;
+ tap_win32_overlapped_t *handle;
- s = qemu_mallocz(sizeof(TAPState));
- if (!s)
- return -1;
- if (tap_win32_open(&s->handle, ifname) < 0) {
+ if (tap_win32_open(&handle, ifname) < 0) {
printf("tap: Could not open '%s'\n", ifname);
return -1;
}
- s->vc = qemu_new_vlan_client(NET_CLIENT_TYPE_TAP,
- vlan, NULL, model, name,
- NULL, tap_receive,
- NULL, NULL, tap_cleanup, s);
+ nc = qemu_new_net_client(&net_tap_win32_info, peer, model, name);
- snprintf(s->vc->info_str, sizeof(s->vc->info_str),
+ s = DO_UPCAST(TAPState, nc, nc);
+
+ snprintf(s->nc.info_str, sizeof(s->nc.info_str),
"tap: ifname=%s", ifname);
+ s->handle = handle;
+
qemu_add_wait_object(s->handle->tap_semaphore, tap_win32_send, s);
+
return 0;
}
-int net_init_tap(QemuOpts *opts, Monitor *mon, const char *name, VLANState *vlan)
+int net_init_tap(const NetClientOptions *opts, const char *name,
+ NetClientState *peer)
{
- const char *ifname;
+ const NetdevTapOptions *tap;
- ifname = qemu_opt_get(opts, "ifname");
+ assert(opts->kind == NET_CLIENT_OPTIONS_KIND_TAP);
+ tap = opts->tap;
- if (!ifname) {
- qemu_error("tap: no interface name\n");
+ if (!tap->has_ifname) {
+ error_report("tap: no interface name");
return -1;
}
- if (tap_win32_init(vlan, "tap", name, ifname) == -1) {
+ if (tap_win32_init(peer, "tap", name, tap->ifname) == -1) {
return -1;
}
- if (vlan) {
- vlan->nb_host_devs++;
- }
-
return 0;
}
-int tap_has_ufo(VLANClientState *vc)
+bool tap_has_ufo(NetClientState *nc)
+{
+ return false;
+}
+
+int tap_has_vnet_hdr(NetClientState *nc)
{
return 0;
}
-int tap_has_vnet_hdr(VLANClientState *vc)
+int tap_probe_vnet_hdr_len(int fd, int len)
{
return 0;
}
-void tap_using_vnet_hdr(VLANClientState *vc, int using_vnet_hdr)
+void tap_fd_set_vnet_hdr_len(int fd, int len)
{
}
-void tap_set_offload(VLANClientState *vc, int csum, int tso4,
+void tap_using_vnet_hdr(NetClientState *nc, bool using_vnet_hdr)
+{
+}
+
+void tap_set_offload(NetClientState *nc, int csum, int tso4,
int tso6, int ecn, int ufo)
{
}
+
+struct vhost_net *tap_get_vhost_net(NetClientState *nc)
+{
+ return NULL;
+}
+
+int tap_has_vnet_hdr_len(NetClientState *nc, int len)
+{
+ return 0;
+}
+
+void tap_set_vnet_hdr_len(NetClientState *nc, int len)
+{
+ abort();
+}
+
+int tap_enable(NetClientState *nc)
+{
+ abort();
+}
+
+int tap_disable(NetClientState *nc)
+{
+ abort();
+}
projects / qemu.git / blobdiff