Archipelago » qemu

/*

 * QEMU USB Net devices

 *

 * Copyright (c) 2006 Thomas Sailer

 * Copyright (c) 2008 Andrzej Zaborowski

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#include "qemu-common.h"

#include "usb.h"

#include "usb-desc.h"

#include "net.h"

#include "qemu-queue.h"

#include "sysemu.h"

#include "iov.h"

/*#define TRAFFIC_DEBUG*/

/* Thanks to NetChip Technologies for donating this product ID.

 * It's for devices with only CDC Ethernet configurations.

 */

#define CDC_VENDOR_NUM          0x0525  /* NetChip */

#define CDC_PRODUCT_NUM         0xa4a1  /* Linux-USB Ethernet Gadget */

/* For hardware that can talk RNDIS and either of the above protocols,

 * use this ID ... the windows INF files will know it.

 */

#define RNDIS_VENDOR_NUM        0x0525  /* NetChip */

#define RNDIS_PRODUCT_NUM       0xa4a2  /* Ethernet/RNDIS Gadget */

enum usbstring_idx {

    STRING_MANUFACTURER                = 1,

    STRING_PRODUCT,

    STRING_ETHADDR,

    STRING_DATA,

    STRING_CONTROL,

    STRING_RNDIS_CONTROL,

    STRING_CDC,

    STRING_SUBSET,

    STRING_RNDIS,

    STRING_SERIALNUMBER,

};

#define DEV_CONFIG_VALUE                1        /* CDC or a subset */

#define DEV_RNDIS_CONFIG_VALUE                2        /* RNDIS; optional */

#define USB_CDC_SUBCLASS_ACM                0x02

#define USB_CDC_SUBCLASS_ETHERNET        0x06

#define USB_CDC_PROTO_NONE                0

#define USB_CDC_ACM_PROTO_VENDOR        0xff

#define USB_CDC_HEADER_TYPE                0x00        /* header_desc */

#define USB_CDC_CALL_MANAGEMENT_TYPE        0x01        /* call_mgmt_descriptor */

#define USB_CDC_ACM_TYPE                0x02        /* acm_descriptor */

#define USB_CDC_UNION_TYPE                0x06        /* union_desc */

#define USB_CDC_ETHERNET_TYPE                0x0f        /* ether_desc */

#define USB_CDC_SEND_ENCAPSULATED_COMMAND        0x00

#define USB_CDC_GET_ENCAPSULATED_RESPONSE        0x01

#define USB_CDC_REQ_SET_LINE_CODING                0x20

#define USB_CDC_REQ_GET_LINE_CODING                0x21

#define USB_CDC_REQ_SET_CONTROL_LINE_STATE        0x22

#define USB_CDC_REQ_SEND_BREAK                        0x23

#define USB_CDC_SET_ETHERNET_MULTICAST_FILTERS        0x40

#define USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER        0x41

#define USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER        0x42

#define USB_CDC_SET_ETHERNET_PACKET_FILTER        0x43

#define USB_CDC_GET_ETHERNET_STATISTIC                0x44

#define LOG2_STATUS_INTERVAL_MSEC        5    /* 1 << 5 == 32 msec */

#define STATUS_BYTECOUNT                16   /* 8 byte header + data */

#define ETH_FRAME_LEN                        1514 /* Max. octets in frame sans FCS */

static const USBDescStrings usb_net_stringtable = {

    [STRING_MANUFACTURER]       = "QEMU",

    [STRING_PRODUCT]            = "RNDIS/QEMU USB Network Device",

    [STRING_ETHADDR]            = "400102030405",

    [STRING_DATA]               = "QEMU USB Net Data Interface",

    [STRING_CONTROL]            = "QEMU USB Net Control Interface",

    [STRING_RNDIS_CONTROL]      = "QEMU USB Net RNDIS Control Interface",

    [STRING_CDC]                = "QEMU USB Net CDC",

    [STRING_SUBSET]             = "QEMU USB Net Subset",

    [STRING_RNDIS]              = "QEMU USB Net RNDIS",

    [STRING_SERIALNUMBER]       = "1",

};

static const USBDescIface desc_iface_rndis[] = {

    {

        /* RNDIS Control Interface */

        .bInterfaceNumber              = 0,

        .bNumEndpoints                 = 1,

        .bInterfaceClass               = USB_CLASS_COMM,

        .bInterfaceSubClass            = USB_CDC_SUBCLASS_ACM,

        .bInterfaceProtocol            = USB_CDC_ACM_PROTO_VENDOR,

        .iInterface                    = STRING_RNDIS_CONTROL,

        .ndesc                         = 4,

        .descs = (USBDescOther[]) {

            {

                /* Header Descriptor */

                .data = (uint8_t[]) {

                    0x05,                       /*  u8    bLength */

                    USB_DT_CS_INTERFACE,        /*  u8    bDescriptorType */

                    USB_CDC_HEADER_TYPE,        /*  u8    bDescriptorSubType */

                    0x10, 0x01,                 /*  le16  bcdCDC */

                },

            },{

                /* Call Management Descriptor */

                .data = (uint8_t[]) {

                    0x05,                       /*  u8    bLength */

                    USB_DT_CS_INTERFACE,        /*  u8    bDescriptorType */

                    USB_CDC_CALL_MANAGEMENT_TYPE, /*  u8    bDescriptorSubType */

                    0x00,                       /*  u8    bmCapabilities */

                    0x01,                       /*  u8    bDataInterface */

                },

            },{

                /* ACM Descriptor */

                .data = (uint8_t[]) {

                    0x04,                       /*  u8    bLength */

                    USB_DT_CS_INTERFACE,        /*  u8    bDescriptorType */

                    USB_CDC_ACM_TYPE,           /*  u8    bDescriptorSubType */

                    0x00,                       /*  u8    bmCapabilities */

                },

            },{

                /* Union Descriptor */

                .data = (uint8_t[]) {

                    0x05,                       /*  u8    bLength */

                    USB_DT_CS_INTERFACE,        /*  u8    bDescriptorType */

                    USB_CDC_UNION_TYPE,         /*  u8    bDescriptorSubType */

                    0x00,                       /*  u8    bMasterInterface0 */

                    0x01,                       /*  u8    bSlaveInterface0 */

                },

            },

        },

        .eps = (USBDescEndpoint[]) {

            {

                .bEndpointAddress      = USB_DIR_IN | 0x01,

                .bmAttributes          = USB_ENDPOINT_XFER_INT,

                .wMaxPacketSize        = STATUS_BYTECOUNT,

                .bInterval             = 1 << LOG2_STATUS_INTERVAL_MSEC,

            },

        }

    },{

        /* RNDIS Data Interface */

        .bInterfaceNumber              = 1,

        .bNumEndpoints                 = 2,

        .bInterfaceClass               = USB_CLASS_CDC_DATA,

        .iInterface                    = STRING_DATA,

        .eps = (USBDescEndpoint[]) {

            {

                .bEndpointAddress      = USB_DIR_IN | 0x02,

                .bmAttributes          = USB_ENDPOINT_XFER_BULK,

                .wMaxPacketSize        = 0x40,

            },{

                .bEndpointAddress      = USB_DIR_OUT | 0x02,

                .bmAttributes          = USB_ENDPOINT_XFER_BULK,

                .wMaxPacketSize        = 0x40,

            }

        }

    }

};

static const USBDescIface desc_iface_cdc[] = {

    {

        /* CDC Control Interface */

        .bInterfaceNumber              = 0,

        .bNumEndpoints                 = 1,

        .bInterfaceClass               = USB_CLASS_COMM,

        .bInterfaceSubClass            = USB_CDC_SUBCLASS_ETHERNET,

        .bInterfaceProtocol            = USB_CDC_PROTO_NONE,

        .iInterface                    = STRING_CONTROL,

        .ndesc                         = 3,

        .descs = (USBDescOther[]) {

            {

                /* Header Descriptor */

                .data = (uint8_t[]) {

                    0x05,                       /*  u8    bLength */

                    USB_DT_CS_INTERFACE,        /*  u8    bDescriptorType */

                    USB_CDC_HEADER_TYPE,        /*  u8    bDescriptorSubType */

                    0x10, 0x01,                 /*  le16  bcdCDC */

                },

            },{

                /* Union Descriptor */

                .data = (uint8_t[]) {

                    0x05,                       /*  u8    bLength */

                    USB_DT_CS_INTERFACE,        /*  u8    bDescriptorType */

                    USB_CDC_UNION_TYPE,         /*  u8    bDescriptorSubType */

                    0x00,                       /*  u8    bMasterInterface0 */

                    0x01,                       /*  u8    bSlaveInterface0 */

                },

            },{

                /* Ethernet Descriptor */

                .data = (uint8_t[]) {

                    0x0d,                       /*  u8    bLength */

                    USB_DT_CS_INTERFACE,        /*  u8    bDescriptorType */

                    USB_CDC_ETHERNET_TYPE,      /*  u8    bDescriptorSubType */

                    STRING_ETHADDR,             /*  u8    iMACAddress */

                    0x00, 0x00, 0x00, 0x00,     /*  le32  bmEthernetStatistics */

                    ETH_FRAME_LEN & 0xff,

                    ETH_FRAME_LEN >> 8,         /*  le16  wMaxSegmentSize */

                    0x00, 0x00,                 /*  le16  wNumberMCFilters */

                    0x00,                       /*  u8    bNumberPowerFilters */

                },

            },

        },

        .eps = (USBDescEndpoint[]) {

            {

                .bEndpointAddress      = USB_DIR_IN | 0x01,

                .bmAttributes          = USB_ENDPOINT_XFER_INT,

                .wMaxPacketSize        = STATUS_BYTECOUNT,

                .bInterval             = 1 << LOG2_STATUS_INTERVAL_MSEC,

            },

        }

    },{

        /* CDC Data Interface (off) */

        .bInterfaceNumber              = 1,

        .bAlternateSetting             = 0,

        .bNumEndpoints                 = 0,

        .bInterfaceClass               = USB_CLASS_CDC_DATA,

    },{

        /* CDC Data Interface */

        .bInterfaceNumber              = 1,

        .bAlternateSetting             = 1,

        .bNumEndpoints                 = 2,

        .bInterfaceClass               = USB_CLASS_CDC_DATA,

        .iInterface                    = STRING_DATA,

        .eps = (USBDescEndpoint[]) {

            {

                .bEndpointAddress      = USB_DIR_IN | 0x02,

                .bmAttributes          = USB_ENDPOINT_XFER_BULK,

                .wMaxPacketSize        = 0x40,

            },{

                .bEndpointAddress      = USB_DIR_OUT | 0x02,

                .bmAttributes          = USB_ENDPOINT_XFER_BULK,

                .wMaxPacketSize        = 0x40,

            }

        }

    }

};

static const USBDescDevice desc_device_net = {

    .bcdUSB                        = 0x0200,

    .bDeviceClass                  = USB_CLASS_COMM,

    .bMaxPacketSize0               = 0x40,

    .bNumConfigurations            = 2,

    .confs = (USBDescConfig[]) {

        {

            .bNumInterfaces        = 2,

            .bConfigurationValue   = DEV_RNDIS_CONFIG_VALUE,

            .iConfiguration        = STRING_RNDIS,

            .bmAttributes          = 0xc0,

            .bMaxPower             = 0x32,

            .nif = ARRAY_SIZE(desc_iface_rndis),

            .ifs = desc_iface_rndis,

        },{

            .bNumInterfaces        = 2,

            .bConfigurationValue   = DEV_CONFIG_VALUE,

            .iConfiguration        = STRING_CDC,

            .bmAttributes          = 0xc0,

            .bMaxPower             = 0x32,

            .nif = ARRAY_SIZE(desc_iface_cdc),

            .ifs = desc_iface_cdc,

        }

    },

};

static const USBDesc desc_net = {

    .id = {

        .idVendor          = RNDIS_VENDOR_NUM,

        .idProduct         = RNDIS_PRODUCT_NUM,

        .bcdDevice         = 0,

        .iManufacturer     = STRING_MANUFACTURER,

        .iProduct          = STRING_PRODUCT,

        .iSerialNumber     = STRING_SERIALNUMBER,

    },

    .full = &desc_device_net,

    .str  = usb_net_stringtable,

};

/*

 * RNDIS Definitions - in theory not specific to USB.

 */

#define RNDIS_MAXIMUM_FRAME_SIZE        1518

#define RNDIS_MAX_TOTAL_SIZE                1558

/* Remote NDIS Versions */

#define RNDIS_MAJOR_VERSION                1

#define RNDIS_MINOR_VERSION                0

/* Status Values */

#define RNDIS_STATUS_SUCCESS                0x00000000U /* Success */

#define RNDIS_STATUS_FAILURE                0xc0000001U /* Unspecified error */

#define RNDIS_STATUS_INVALID_DATA        0xc0010015U /* Invalid data */

#define RNDIS_STATUS_NOT_SUPPORTED        0xc00000bbU /* Unsupported request */

#define RNDIS_STATUS_MEDIA_CONNECT        0x4001000bU /* Device connected */

#define RNDIS_STATUS_MEDIA_DISCONNECT        0x4001000cU /* Device disconnected */

/* Message Set for Connectionless (802.3) Devices */

enum {

    RNDIS_PACKET_MSG                = 1,

    RNDIS_INITIALIZE_MSG        = 2,        /* Initialize device */

    RNDIS_HALT_MSG                = 3,

    RNDIS_QUERY_MSG                = 4,

    RNDIS_SET_MSG                = 5,

    RNDIS_RESET_MSG                = 6,

    RNDIS_INDICATE_STATUS_MSG        = 7,

    RNDIS_KEEPALIVE_MSG                = 8,

};

/* Message completion */

enum {

    RNDIS_INITIALIZE_CMPLT        = 0x80000002U,

    RNDIS_QUERY_CMPLT                = 0x80000004U,

    RNDIS_SET_CMPLT                = 0x80000005U,

    RNDIS_RESET_CMPLT                = 0x80000006U,

    RNDIS_KEEPALIVE_CMPLT        = 0x80000008U,

};

/* Device Flags */

enum {

    RNDIS_DF_CONNECTIONLESS        = 1,

    RNDIS_DF_CONNECTIONORIENTED        = 2,

};

#define RNDIS_MEDIUM_802_3                0x00000000U

/* from drivers/net/sk98lin/h/skgepnmi.h */

#define OID_PNP_CAPABILITIES                0xfd010100

#define OID_PNP_SET_POWER                0xfd010101

#define OID_PNP_QUERY_POWER                0xfd010102

#define OID_PNP_ADD_WAKE_UP_PATTERN        0xfd010103

#define OID_PNP_REMOVE_WAKE_UP_PATTERN        0xfd010104

#define OID_PNP_ENABLE_WAKE_UP                0xfd010106

typedef uint32_t le32;

typedef struct rndis_init_msg_type {

    le32 MessageType;

    le32 MessageLength;

    le32 RequestID;

    le32 MajorVersion;

    le32 MinorVersion;

    le32 MaxTransferSize;

} rndis_init_msg_type;

typedef struct rndis_init_cmplt_type {

    le32 MessageType;

    le32 MessageLength;

    le32 RequestID;

    le32 Status;

    le32 MajorVersion;

    le32 MinorVersion;

    le32 DeviceFlags;

    le32 Medium;

    le32 MaxPacketsPerTransfer;

    le32 MaxTransferSize;

    le32 PacketAlignmentFactor;

    le32 AFListOffset;

    le32 AFListSize;

} rndis_init_cmplt_type;

typedef struct rndis_halt_msg_type {

    le32 MessageType;

    le32 MessageLength;

    le32 RequestID;

} rndis_halt_msg_type;

typedef struct rndis_query_msg_type {

    le32 MessageType;

    le32 MessageLength;

    le32 RequestID;

    le32 OID;

    le32 InformationBufferLength;

    le32 InformationBufferOffset;

    le32 DeviceVcHandle;

} rndis_query_msg_type;

typedef struct rndis_query_cmplt_type {

    le32 MessageType;

    le32 MessageLength;

    le32 RequestID;

    le32 Status;

    le32 InformationBufferLength;

    le32 InformationBufferOffset;

} rndis_query_cmplt_type;

typedef struct rndis_set_msg_type {

    le32 MessageType;

    le32 MessageLength;

    le32 RequestID;

    le32 OID;

    le32 InformationBufferLength;

    le32 InformationBufferOffset;

    le32 DeviceVcHandle;

} rndis_set_msg_type;

typedef struct rndis_set_cmplt_type {

    le32 MessageType;

    le32 MessageLength;

    le32 RequestID;

    le32 Status;

} rndis_set_cmplt_type;

typedef struct rndis_reset_msg_type {

    le32 MessageType;

    le32 MessageLength;

    le32 Reserved;

} rndis_reset_msg_type;

typedef struct rndis_reset_cmplt_type {

    le32 MessageType;

    le32 MessageLength;

    le32 Status;

    le32 AddressingReset;

} rndis_reset_cmplt_type;

typedef struct rndis_indicate_status_msg_type {

    le32 MessageType;

    le32 MessageLength;

    le32 Status;

    le32 StatusBufferLength;

    le32 StatusBufferOffset;

} rndis_indicate_status_msg_type;

typedef struct rndis_keepalive_msg_type {

    le32 MessageType;

    le32 MessageLength;

    le32 RequestID;

} rndis_keepalive_msg_type;

typedef struct rndis_keepalive_cmplt_type {

    le32 MessageType;

    le32 MessageLength;

    le32 RequestID;

    le32 Status;

} rndis_keepalive_cmplt_type;

struct rndis_packet_msg_type {

    le32 MessageType;

    le32 MessageLength;

    le32 DataOffset;

    le32 DataLength;

    le32 OOBDataOffset;

    le32 OOBDataLength;

    le32 NumOOBDataElements;

    le32 PerPacketInfoOffset;

    le32 PerPacketInfoLength;

    le32 VcHandle;

    le32 Reserved;

};

struct rndis_config_parameter {

    le32 ParameterNameOffset;

    le32 ParameterNameLength;

    le32 ParameterType;

    le32 ParameterValueOffset;

    le32 ParameterValueLength;

};

/* implementation specific */

enum rndis_state

{

    RNDIS_UNINITIALIZED,

    RNDIS_INITIALIZED,

    RNDIS_DATA_INITIALIZED,

};

/* from ndis.h */

enum ndis_oid {

    /* Required Object IDs (OIDs) */

    OID_GEN_SUPPORTED_LIST                = 0x00010101,

    OID_GEN_HARDWARE_STATUS                = 0x00010102,

    OID_GEN_MEDIA_SUPPORTED                = 0x00010103,

    OID_GEN_MEDIA_IN_USE                = 0x00010104,

    OID_GEN_MAXIMUM_LOOKAHEAD                = 0x00010105,

    OID_GEN_MAXIMUM_FRAME_SIZE                = 0x00010106,

    OID_GEN_LINK_SPEED                        = 0x00010107,

    OID_GEN_TRANSMIT_BUFFER_SPACE        = 0x00010108,

    OID_GEN_RECEIVE_BUFFER_SPACE        = 0x00010109,

    OID_GEN_TRANSMIT_BLOCK_SIZE                = 0x0001010a,

    OID_GEN_RECEIVE_BLOCK_SIZE                = 0x0001010b,

    OID_GEN_VENDOR_ID                        = 0x0001010c,

    OID_GEN_VENDOR_DESCRIPTION                = 0x0001010d,

    OID_GEN_CURRENT_PACKET_FILTER        = 0x0001010e,

    OID_GEN_CURRENT_LOOKAHEAD                = 0x0001010f,

    OID_GEN_DRIVER_VERSION                = 0x00010110,

    OID_GEN_MAXIMUM_TOTAL_SIZE                = 0x00010111,

    OID_GEN_PROTOCOL_OPTIONS                = 0x00010112,

    OID_GEN_MAC_OPTIONS                        = 0x00010113,

    OID_GEN_MEDIA_CONNECT_STATUS        = 0x00010114,

    OID_GEN_MAXIMUM_SEND_PACKETS        = 0x00010115,

    OID_GEN_VENDOR_DRIVER_VERSION        = 0x00010116,

    OID_GEN_SUPPORTED_GUIDS                = 0x00010117,

    OID_GEN_NETWORK_LAYER_ADDRESSES        = 0x00010118,

    OID_GEN_TRANSPORT_HEADER_OFFSET        = 0x00010119,

    OID_GEN_MACHINE_NAME                = 0x0001021a,

    OID_GEN_RNDIS_CONFIG_PARAMETER        = 0x0001021b,

    OID_GEN_VLAN_ID                        = 0x0001021c,

    /* Optional OIDs */

    OID_GEN_MEDIA_CAPABILITIES                = 0x00010201,

    OID_GEN_PHYSICAL_MEDIUM                = 0x00010202,

    /* Required statistics OIDs */

    OID_GEN_XMIT_OK                        = 0x00020101,

    OID_GEN_RCV_OK                        = 0x00020102,

    OID_GEN_XMIT_ERROR                        = 0x00020103,

    OID_GEN_RCV_ERROR                        = 0x00020104,

    OID_GEN_RCV_NO_BUFFER                = 0x00020105,

    /* Optional statistics OIDs */

    OID_GEN_DIRECTED_BYTES_XMIT                = 0x00020201,

    OID_GEN_DIRECTED_FRAMES_XMIT        = 0x00020202,

    OID_GEN_MULTICAST_BYTES_XMIT        = 0x00020203,

    OID_GEN_MULTICAST_FRAMES_XMIT        = 0x00020204,

    OID_GEN_BROADCAST_BYTES_XMIT        = 0x00020205,

    OID_GEN_BROADCAST_FRAMES_XMIT        = 0x00020206,

    OID_GEN_DIRECTED_BYTES_RCV                = 0x00020207,

    OID_GEN_DIRECTED_FRAMES_RCV                = 0x00020208,

    OID_GEN_MULTICAST_BYTES_RCV                = 0x00020209,

    OID_GEN_MULTICAST_FRAMES_RCV        = 0x0002020a,

    OID_GEN_BROADCAST_BYTES_RCV                = 0x0002020b,

    OID_GEN_BROADCAST_FRAMES_RCV        = 0x0002020c,

    OID_GEN_RCV_CRC_ERROR                = 0x0002020d,

    OID_GEN_TRANSMIT_QUEUE_LENGTH        = 0x0002020e,

    OID_GEN_GET_TIME_CAPS                = 0x0002020f,

    OID_GEN_GET_NETCARD_TIME                = 0x00020210,

    OID_GEN_NETCARD_LOAD                = 0x00020211,

    OID_GEN_DEVICE_PROFILE                = 0x00020212,

    OID_GEN_INIT_TIME_MS                = 0x00020213,

    OID_GEN_RESET_COUNTS                = 0x00020214,

    OID_GEN_MEDIA_SENSE_COUNTS                = 0x00020215,

    OID_GEN_FRIENDLY_NAME                = 0x00020216,

    OID_GEN_MINIPORT_INFO                = 0x00020217,

    OID_GEN_RESET_VERIFY_PARAMETERS        = 0x00020218,

    /* IEEE 802.3 (Ethernet) OIDs */

    OID_802_3_PERMANENT_ADDRESS                = 0x01010101,

    OID_802_3_CURRENT_ADDRESS                = 0x01010102,

    OID_802_3_MULTICAST_LIST                = 0x01010103,

    OID_802_3_MAXIMUM_LIST_SIZE                = 0x01010104,

    OID_802_3_MAC_OPTIONS                = 0x01010105,

    OID_802_3_RCV_ERROR_ALIGNMENT        = 0x01020101,

    OID_802_3_XMIT_ONE_COLLISION        = 0x01020102,

    OID_802_3_XMIT_MORE_COLLISIONS        = 0x01020103,

    OID_802_3_XMIT_DEFERRED                = 0x01020201,

    OID_802_3_XMIT_MAX_COLLISIONS        = 0x01020202,

    OID_802_3_RCV_OVERRUN                = 0x01020203,

    OID_802_3_XMIT_UNDERRUN                = 0x01020204,

    OID_802_3_XMIT_HEARTBEAT_FAILURE        = 0x01020205,

    OID_802_3_XMIT_TIMES_CRS_LOST        = 0x01020206,

    OID_802_3_XMIT_LATE_COLLISIONS        = 0x01020207,

};

static const uint32_t oid_supported_list[] =

{

    /* the general stuff */

    OID_GEN_SUPPORTED_LIST,

    OID_GEN_HARDWARE_STATUS,

    OID_GEN_MEDIA_SUPPORTED,

    OID_GEN_MEDIA_IN_USE,

    OID_GEN_MAXIMUM_FRAME_SIZE,

    OID_GEN_LINK_SPEED,

    OID_GEN_TRANSMIT_BLOCK_SIZE,

    OID_GEN_RECEIVE_BLOCK_SIZE,

    OID_GEN_VENDOR_ID,

    OID_GEN_VENDOR_DESCRIPTION,

    OID_GEN_VENDOR_DRIVER_VERSION,

    OID_GEN_CURRENT_PACKET_FILTER,

    OID_GEN_MAXIMUM_TOTAL_SIZE,

    OID_GEN_MEDIA_CONNECT_STATUS,

    OID_GEN_PHYSICAL_MEDIUM,

    /* the statistical stuff */

    OID_GEN_XMIT_OK,

    OID_GEN_RCV_OK,

    OID_GEN_XMIT_ERROR,

    OID_GEN_RCV_ERROR,

    OID_GEN_RCV_NO_BUFFER,

    /* IEEE 802.3 */

    /* the general stuff */

    OID_802_3_PERMANENT_ADDRESS,

    OID_802_3_CURRENT_ADDRESS,

    OID_802_3_MULTICAST_LIST,

    OID_802_3_MAC_OPTIONS,

    OID_802_3_MAXIMUM_LIST_SIZE,

    /* the statistical stuff */

    OID_802_3_RCV_ERROR_ALIGNMENT,

    OID_802_3_XMIT_ONE_COLLISION,

    OID_802_3_XMIT_MORE_COLLISIONS,

};

#define NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA        (1 << 0)

#define NDIS_MAC_OPTION_RECEIVE_SERIALIZED        (1 << 1)

#define NDIS_MAC_OPTION_TRANSFERS_NOT_PEND        (1 << 2)

#define NDIS_MAC_OPTION_NO_LOOPBACK                (1 << 3)

#define NDIS_MAC_OPTION_FULL_DUPLEX                (1 << 4)

#define NDIS_MAC_OPTION_EOTX_INDICATION                (1 << 5)

#define NDIS_MAC_OPTION_8021P_PRIORITY                (1 << 6)

struct rndis_response {

    QTAILQ_ENTRY(rndis_response) entries;

    uint32_t length;

    uint8_t buf[0];

};

typedef struct USBNetState {

    USBDevice dev;

    enum rndis_state rndis_state;

    uint32_t medium;

    uint32_t speed;

    uint32_t media_state;

    uint16_t filter;

    uint32_t vendorid;

    unsigned int out_ptr;

    uint8_t out_buf[2048];

    USBPacket *inpkt;

    unsigned int in_ptr, in_len;

    uint8_t in_buf[2048];

    char usbstring_mac[13];

    NICState *nic;

    NICConf conf;

    QTAILQ_HEAD(rndis_resp_head, rndis_response) rndis_resp;

} USBNetState;

static int is_rndis(USBNetState *s)

{

    return s->dev.config->bConfigurationValue == DEV_RNDIS_CONFIG_VALUE;

}

static int ndis_query(USBNetState *s, uint32_t oid,

                      uint8_t *inbuf, unsigned int inlen, uint8_t *outbuf,

                      size_t outlen)

{

    unsigned int i;

    switch (oid) {

    /* general oids (table 4-1) */

    /* mandatory */

    case OID_GEN_SUPPORTED_LIST:

        for (i = 0; i < ARRAY_SIZE(oid_supported_list); i++)

            ((le32 *) outbuf)[i] = cpu_to_le32(oid_supported_list[i]);

        return sizeof(oid_supported_list);

    /* mandatory */

    case OID_GEN_HARDWARE_STATUS:

        *((le32 *) outbuf) = cpu_to_le32(0);

        return sizeof(le32);

    /* mandatory */

    case OID_GEN_MEDIA_SUPPORTED:

        *((le32 *) outbuf) = cpu_to_le32(s->medium);

        return sizeof(le32);

    /* mandatory */

    case OID_GEN_MEDIA_IN_USE:

        *((le32 *) outbuf) = cpu_to_le32(s->medium);

        return sizeof(le32);

    /* mandatory */

    case OID_GEN_MAXIMUM_FRAME_SIZE:

        *((le32 *) outbuf) = cpu_to_le32(ETH_FRAME_LEN);

        return sizeof(le32);

    /* mandatory */

    case OID_GEN_LINK_SPEED:

        *((le32 *) outbuf) = cpu_to_le32(s->speed);

        return sizeof(le32);

    /* mandatory */

    case OID_GEN_TRANSMIT_BLOCK_SIZE:

        *((le32 *) outbuf) = cpu_to_le32(ETH_FRAME_LEN);

        return sizeof(le32);

    /* mandatory */

    case OID_GEN_RECEIVE_BLOCK_SIZE:

        *((le32 *) outbuf) = cpu_to_le32(ETH_FRAME_LEN);

        return sizeof(le32);

    /* mandatory */

    case OID_GEN_VENDOR_ID:

        *((le32 *) outbuf) = cpu_to_le32(s->vendorid);

        return sizeof(le32);

    /* mandatory */

    case OID_GEN_VENDOR_DESCRIPTION:

        pstrcpy((char *)outbuf, outlen, "QEMU USB RNDIS Net");

        return strlen((char *)outbuf) + 1;

    case OID_GEN_VENDOR_DRIVER_VERSION:

        *((le32 *) outbuf) = cpu_to_le32(1);

        return sizeof(le32);

    /* mandatory */

    case OID_GEN_CURRENT_PACKET_FILTER:

        *((le32 *) outbuf) = cpu_to_le32(s->filter);

        return sizeof(le32);

    /* mandatory */

    case OID_GEN_MAXIMUM_TOTAL_SIZE:

        *((le32 *) outbuf) = cpu_to_le32(RNDIS_MAX_TOTAL_SIZE);

        return sizeof(le32);

    /* mandatory */

    case OID_GEN_MEDIA_CONNECT_STATUS:

        *((le32 *) outbuf) = cpu_to_le32(s->media_state);

        return sizeof(le32);

    case OID_GEN_PHYSICAL_MEDIUM:

        *((le32 *) outbuf) = cpu_to_le32(0);

        return sizeof(le32);

    case OID_GEN_MAC_OPTIONS:

        *((le32 *) outbuf) = cpu_to_le32(

                        NDIS_MAC_OPTION_RECEIVE_SERIALIZED |

                        NDIS_MAC_OPTION_FULL_DUPLEX);

        return sizeof(le32);

    /* statistics OIDs (table 4-2) */

    /* mandatory */

    case OID_GEN_XMIT_OK:

        *((le32 *) outbuf) = cpu_to_le32(0);

        return sizeof(le32);

    /* mandatory */

    case OID_GEN_RCV_OK:

        *((le32 *) outbuf) = cpu_to_le32(0);

        return sizeof(le32);

    /* mandatory */

    case OID_GEN_XMIT_ERROR:

        *((le32 *) outbuf) = cpu_to_le32(0);

        return sizeof(le32);

    /* mandatory */

    case OID_GEN_RCV_ERROR:

        *((le32 *) outbuf) = cpu_to_le32(0);

        return sizeof(le32);

    /* mandatory */

    case OID_GEN_RCV_NO_BUFFER:

        *((le32 *) outbuf) = cpu_to_le32(0);

        return sizeof(le32);

    /* ieee802.3 OIDs (table 4-3) */

    /* mandatory */

    case OID_802_3_PERMANENT_ADDRESS:

        memcpy(outbuf, s->conf.macaddr.a, 6);

        return 6;

    /* mandatory */

    case OID_802_3_CURRENT_ADDRESS:

        memcpy(outbuf, s->conf.macaddr.a, 6);

        return 6;

    /* mandatory */

    case OID_802_3_MULTICAST_LIST:

        *((le32 *) outbuf) = cpu_to_le32(0xe0000000);

        return sizeof(le32);

    /* mandatory */

    case OID_802_3_MAXIMUM_LIST_SIZE:

        *((le32 *) outbuf) = cpu_to_le32(1);

        return sizeof(le32);

    case OID_802_3_MAC_OPTIONS:

        return 0;

    /* ieee802.3 statistics OIDs (table 4-4) */

    /* mandatory */

    case OID_802_3_RCV_ERROR_ALIGNMENT:

        *((le32 *) outbuf) = cpu_to_le32(0);

        return sizeof(le32);

    /* mandatory */

    case OID_802_3_XMIT_ONE_COLLISION:

        *((le32 *) outbuf) = cpu_to_le32(0);

        return sizeof(le32);

    /* mandatory */

    case OID_802_3_XMIT_MORE_COLLISIONS:

        *((le32 *) outbuf) = cpu_to_le32(0);

        return sizeof(le32);

    default:

        fprintf(stderr, "usbnet: unknown OID 0x%08x\n", oid);

        return 0;

    }

    return -1;

}

static int ndis_set(USBNetState *s, uint32_t oid,

                uint8_t *inbuf, unsigned int inlen)

{

    switch (oid) {

    case OID_GEN_CURRENT_PACKET_FILTER:

        s->filter = le32_to_cpup((le32 *) inbuf);

        if (s->filter) {

            s->rndis_state = RNDIS_DATA_INITIALIZED;

        } else {

            s->rndis_state = RNDIS_INITIALIZED;

        }

        return 0;

    case OID_802_3_MULTICAST_LIST:

        return 0;

    }

    return -1;

}

static int rndis_get_response(USBNetState *s, uint8_t *buf)

{

    int ret = 0;

    struct rndis_response *r = s->rndis_resp.tqh_first;

    if (!r)

        return ret;

    QTAILQ_REMOVE(&s->rndis_resp, r, entries);

    ret = r->length;

    memcpy(buf, r->buf, r->length);

    g_free(r);

    return ret;

}

static void *rndis_queue_response(USBNetState *s, unsigned int length)

{

    struct rndis_response *r =

            g_malloc0(sizeof(struct rndis_response) + length);

    QTAILQ_INSERT_TAIL(&s->rndis_resp, r, entries);

    r->length = length;

    return &r->buf[0];

}

static void rndis_clear_responsequeue(USBNetState *s)

{

    struct rndis_response *r;

    while ((r = s->rndis_resp.tqh_first)) {

        QTAILQ_REMOVE(&s->rndis_resp, r, entries);

        g_free(r);

    }

}

static int rndis_init_response(USBNetState *s, rndis_init_msg_type *buf)

{

    rndis_init_cmplt_type *resp =

            rndis_queue_response(s, sizeof(rndis_init_cmplt_type));

    if (!resp)

        return USB_RET_STALL;

    resp->MessageType = cpu_to_le32(RNDIS_INITIALIZE_CMPLT);

    resp->MessageLength = cpu_to_le32(sizeof(rndis_init_cmplt_type));

    resp->RequestID = buf->RequestID; /* Still LE in msg buffer */

    resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS);

    resp->MajorVersion = cpu_to_le32(RNDIS_MAJOR_VERSION);

    resp->MinorVersion = cpu_to_le32(RNDIS_MINOR_VERSION);

    resp->DeviceFlags = cpu_to_le32(RNDIS_DF_CONNECTIONLESS);

    resp->Medium = cpu_to_le32(RNDIS_MEDIUM_802_3);

    resp->MaxPacketsPerTransfer = cpu_to_le32(1);

    resp->MaxTransferSize = cpu_to_le32(ETH_FRAME_LEN +

                    sizeof(struct rndis_packet_msg_type) + 22);

    resp->PacketAlignmentFactor = cpu_to_le32(0);

    resp->AFListOffset = cpu_to_le32(0);

    resp->AFListSize = cpu_to_le32(0);

    return 0;

}

static int rndis_query_response(USBNetState *s,

                rndis_query_msg_type *buf, unsigned int length)

{

    rndis_query_cmplt_type *resp;

    /* oid_supported_list is the largest data reply */

    uint8_t infobuf[sizeof(oid_supported_list)];

    uint32_t bufoffs, buflen;