net: change vnet-hdr TAP prototypes

[qemu.git] / net / tap-win32.c

diff --git a/net/tap-win32.c b/net/tap-win32.c
index 7d92df2aa3e5896ecc890d1a69d96208113ce612..edf26c4720c58ff4d7ae00e14d7b0f6d82314832 100644 (file)
--- a/net/tap-win32.c
+++ b/net/tap-win32.c
@@ -25,9 +25,15 @@
  *  along with this program (see the file COPYING included with this
  *  distribution); if not, see <http://www.gnu.org/licenses/>.
  */
  *  along with this program (see the file COPYING included with this
  *  distribution); if not, see <http://www.gnu.org/licenses/>.
  */

+
+#include "tap_int.h"
+

 #include "qemu-common.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>
 #include <stdio.h>
 #include <windows.h>
 #include <winioctl.h>


@@ -476,7 +482,7 @@ static int tap_win32_write(tap_win32_overlapped_t *overlapped,
         }
     }
 
         }
     }
 

-    return 0;
+    return write_size;

 }
 
 static DWORD WINAPI tap_win32_thread_entry(LPVOID param)
 }
 
 static DWORD WINAPI tap_win32_thread_entry(LPVOID param)


@@ -560,7 +566,7 @@ static void tap_win32_free_buffer(tap_win32_overlapped_t *overlapped,
 }
 
 static int tap_win32_open(tap_win32_overlapped_t **phandle,
 }
 
 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];
 {
     char device_path[256];
     char device_guid[0x100];


@@ -575,10 +581,10 @@ static int tap_win32_open(tap_win32_overlapped_t **phandle,
     } version;
     DWORD version_len;
     DWORD idThread;
     } 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)
 
     rc = get_device_guid(device_guid, sizeof(device_guid), name_buffer, sizeof(name_buffer));
     if (rc)


@@ -619,33 +625,32 @@ static int tap_win32_open(tap_win32_overlapped_t **phandle,
 
     *phandle = &tap_overlapped;
 
 
     *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 {
     return 0;
 }
 
 /********************************************/
 
  typedef struct TAPState {

-     VLANClientState *vc;
+     NetClientState nc;

      tap_win32_overlapped_t *handle;
  } TAPState;
 
      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_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);
 }
 
     return tap_win32_write(s->handle, buf, size);
 }


@@ -659,32 +664,113 @@ static void tap_win32_send(void *opaque)
 
     size = tap_win32_read(s->handle, &buf, max_size);
     if (size > 0) {
 
     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);
     }
 }
 
         tap_win32_free_buffer(s->handle, buf);
     }
 }
 

-int tap_win32_init(VLANState *vlan, const char *model,
-                   const char *name, const char *ifname)
+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;
     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;
     }
 
         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);
+
+    s = DO_UPCAST(TAPState, nc, nc);

 
 

-    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
+    snprintf(s->nc.info_str, sizeof(s->nc.info_str),

              "tap: ifname=%s", ifname);
 
              "tap: ifname=%s", ifname);
 

+    s->handle = handle;
+

     qemu_add_wait_object(s->handle->tap_semaphore, tap_win32_send, s);
     qemu_add_wait_object(s->handle->tap_semaphore, tap_win32_send, s);

+
+    return 0;
+}
+
+int net_init_tap(const NetClientOptions *opts, const char *name,
+                 NetClientState *peer)
+{
+    const NetdevTapOptions *tap;
+
+    assert(opts->kind == NET_CLIENT_OPTIONS_KIND_TAP);
+    tap = opts->tap;
+
+    if (!tap->has_ifname) {
+        error_report("tap: no interface name");
+        return -1;
+    }
+
+    if (tap_win32_init(peer, "tap", name, tap->ifname) == -1) {
+        return -1;
+    }
+

     return 0;
 }
     return 0;
 }

+
+bool tap_has_ufo(NetClientState *nc)
+{
+    return false;
+}
+
+bool tap_has_vnet_hdr(NetClientState *nc)
+{
+    return false;
+}
+
+int tap_probe_vnet_hdr_len(int fd, int len)
+{
+    return 0;
+}
+
+void tap_fd_set_vnet_hdr_len(int fd, int len)
+{
+}
+
+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;
+}
+
+bool tap_has_vnet_hdr_len(NetClientState *nc, int len)
+{
+    return false;
+}
+
+void tap_set_vnet_hdr_len(NetClientState *nc, int len)
+{
+    abort();
+}
+
+int tap_enable(NetClientState *nc)
+{
+    abort();
+}
+
+int tap_disable(NetClientState *nc)
+{
+    abort();
+}