/ - Diff - qemu - Greek Research and Technology Network's projects

         return -1;
+    }
     static void nic_receive(VLANClientState *vc, const uint8_t * buf, size_t size)
     static ssize_t nic_receive(VLANClientState *vc, const uint8_t * buf, size_t size)
+    {
         uint16_t data[10];
         dp8393xState *s = vc->opaque;
-...
         packet_type = receive_filter(s, buf, size);
         if (packet_type < 0) {
             DPRINTF("packet not for netcard\n");
             return;
             return -1;
+        }
         /* XXX: Check byte ordering */
-...
             s->memory_rw(s->mem_opaque, address, (uint8_t*)data, size, 0);
             if (data[0 * width] & 0x1) {
                 /* Still EOL ; stop reception */
                 return;
                 return -1;
             } else {
                 s->regs[SONIC_CRDA] = s->regs[SONIC_LLFA];
+            }
-...
         /* Done */
         dp8393x_update_irq(s);
         return size;
+    }
     static void nic_reset(void *opaque)

         return (s->mac_reg[RCTL] & E1000_RCTL_EN);
+    }
     static void
     static ssize_t
     e1000_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
+    {
         E1000State *s = vc->opaque;
-...
         uint8_t vlan_status = 0, vlan_offset = 0;
         if (!(s->mac_reg[RCTL] & E1000_RCTL_EN))
             return;
             return -1;
         if (size > s->rxbuf_size) {
             DBGOUT(RX, "packet too large for buffers (%lu > %d)\n",
                    (unsigned long)size, s->rxbuf_size);
             return;
             return -1;
+        }
         if (!receive_filter(s, buf, size))
             return;
             return size;
         if (vlan_enabled(s) && is_vlan_packet(s, buf)) {
             vlan_special = cpu_to_le16(be16_to_cpup((uint16_t *)(buf + 14)));
-...
         do {
             if (s->mac_reg[RDH] == s->mac_reg[RDT] && s->check_rxov) {
                 set_ics(s, 0, E1000_ICS_RXO);
                 return;
                 return -1;
+            }
             base = ((uint64_t)s->mac_reg[RDBAH] << 32) + s->mac_reg[RDBAL] +
                    sizeof(desc) * s->mac_reg[RDH];
-...
                 DBGOUT(RXERR, "RDH wraparound @%x, RDT %x, RDLEN %x\n",
                        rdh_start, s->mac_reg[RDT], s->mac_reg[RDLEN]);
                 set_ics(s, 0, E1000_ICS_RXO);
                 return;
                 return -1;
+            }
         } while (desc.buffer_addr == 0);
-...
             n |= E1000_ICS_RXDMT0;
         set_ics(s, 0, n);
         return size;
+    }
     static uint32_t

         //~ return !eepro100_buffer_full(s);
+    }
     static void nic_receive(VLANClientState *vc, const uint8_t * buf, size_t size)
     static ssize_t nic_receive(VLANClientState *vc, const uint8_t * buf, size_t size)
+    {
         /* TODO:
          * - Magic packets should set bit 30 in power management driver register.
-...
         if (s->configuration[8] & 0x80) {
             /* CSMA is disabled. */
             logout("%p received while CSMA is disabled\n", s);
             return;
             return -1;
         } else if (size < 64 && (s->configuration[7] & 1)) {
             /* Short frame and configuration byte 7/0 (discard short receive) set:
              * Short frame is discarded */
             logout("%p received short frame (%d byte)\n", s, size);
             s->statistics.rx_short_frame_errors++;
             //~ return;
             //~ return -1;
         } else if ((size > MAX_ETH_FRAME_SIZE + 4) && !(s->configuration[18] & 8)) {
             /* Long frame and configuration byte 18/3 (long receive ok) not set:
              * Long frames are discarded. */
             logout("%p received long frame (%d byte), ignored\n", s, size);
             return;
             return -1;
         } else if (memcmp(buf, s->macaddr, 6) == 0) {       // !!!
             /* Frame matches individual address. */
             /* TODO: check configuration byte 15/4 (ignore U/L). */
-...
             assert(!(s->configuration[21] & BIT(3)));
             int mcast_idx = compute_mcast_idx(buf);
             if (!(s->mult[mcast_idx >> 3] & (1 << (mcast_idx & 7)))) {
                 return;
                 return size;
+            }
             rfd_status |= 0x0002;
         } else if (s->configuration[15] & 1) {
-...
         } else {
             logout("%p received frame, ignored, len=%d,%s\n", s, size,
                    nic_dump(buf, size));
             return;
             return size;
+        }
         if (get_ru_state(s) != ru_ready) {
-...
             logout("no ressources, state=%u\n", get_ru_state(s));
             s->statistics.rx_resource_errors++;
             //~ assert(!"no ressources");
             return;
             return -1;
+        }
         //~ !!!
     //~ $3 = {status = 0x0, command = 0xc000, link = 0x2d220, rx_buf_addr = 0x207dc, count = 0x0, size = 0x5f8, packet = {0x0 <repeats 1518 times>}}
-...
             /* S bit is set. */
             set_ru_state(s, ru_suspended);
+        }
         return size;
+    }
     static int nic_load(QEMUFile * f, void *opaque, int version_id)

     	return 1;
+    }
     static void eth_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
     static ssize_t eth_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
+    {
     	unsigned char sa_bcast[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
     	struct fs_eth *eth = vc->opaque;
-...
     	int r_bcast = eth->regs[RW_REC_CTRL] & 8;
     	if (size < 12)
     		return;
     		return -1;
     	D(printf("%x.%x.%x.%x.%x.%x ma=%d %d bc=%d\n",
     		 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5],
-...
     	    && (!use_ma1 || memcmp(buf, eth->macaddr[1], 6))
     	    && (!r_bcast || memcmp(buf, sa_bcast, 6))
     	    && !eth_match_groupaddr(eth, buf))
     		return;
     		return size;
     	/* FIXME: Find another way to pass on the fake csum.  */
     	etraxfs_dmac_input(eth->dma_in, (void *)buf, size + 4, 1);
             return size;
+    }
     static int eth_tx_push(void *opaque, unsigned char *buf, int len)

b/hw/mcf_fec.c
353	353	return s->rx_enabled;
354	354	}
355	355
356		static void mcf_fec_receive(VLANClientState vc, const uint8_t buf, size_t size)
	356	static ssize_t mcf_fec_receive(VLANClientState vc, const uint8_t buf, size_t size)
357	357	{
358	358	mcf_fec_state *s = vc->opaque;
359	359	mcf_fec_bd bd;
...	...
426	426	s->rx_descriptor = addr;
427	427	mcf_fec_enable_rx(s);
428	428	mcf_fec_update(s);
	429	return size;
429	430	}
430	431
431	432	static CPUReadMemoryFunc *mcf_fec_readfn[] = {

         return !mipsnet_buffer_full(s);
+    }
     static void mipsnet_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
     static ssize_t mipsnet_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
+    {
         MIPSnetState *s = vc->opaque;
-...
         printf("mipsnet: receiving len=%d\n", size);
     #endif
         if (!mipsnet_can_receive(vc))
             return;
             return -1;
         s->busy = 1;
-...
         /* Now we can signal we have received something. */
         s->intctl |= MIPSNET_INTCTL_RXDONE;
         mipsnet_update_irq(s);
         return size;
+    }
     static uint32_t mipsnet_ioport_read(void *opaque, uint32_t addr)

b/hw/musicpal.c
562	562	return 1;
563	563	}
564	564
565		static void eth_receive(VLANClientState vc, const uint8_t buf, size_t size)
	565	static ssize_t eth_receive(VLANClientState vc, const uint8_t buf, size_t size)
566	566	{
567	567	mv88w8618_eth_state *s = vc->opaque;
568	568	uint32_t desc_addr;
...	...
586	586	if (s->icr & s->imr)
587	587	qemu_irq_raise(s->irq);
588	588	eth_rx_desc_put(desc_addr, &desc);
589		return;
	589	return size;
590	590	}
591	591	desc_addr = desc.next;
592	592	} while (desc_addr != s->rx_queue[i]);
593	593	}
	594	return size;
594	595	}
595	596
596	597	static void eth_tx_desc_put(uint32_t addr, mv88w8618_tx_desc *desc)

     #define MIN_BUF_SIZE 60
     static void ne2000_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
     static ssize_t ne2000_receive(VLANClientState *vc, const uint8_t *buf, size_t size_)
+    {
         NE2000State *s = vc->opaque;
         int size = size_;
         uint8_t *p;
         unsigned int total_len, next, avail, len, index, mcast_idx;
         uint8_t buf1[60];
-...
     #endif
         if (s->cmd & E8390_STOP || ne2000_buffer_full(s))
             return;
             return -1;
         /* XXX: check this */
         if (s->rxcr & 0x10) {
-...
             if (!memcmp(buf,  broadcast_macaddr, 6)) {
                 /* broadcast address */
                 if (!(s->rxcr & 0x04))
                     return;
                     return size;
             } else if (buf[0] & 0x01) {
                 /* multicast */
                 if (!(s->rxcr & 0x08))
                     return;
                     return size;
                 mcast_idx = compute_mcast_idx(buf);
                 if (!(s->mult[mcast_idx >> 3] & (1 << (mcast_idx & 7))))
                     return;
                     return size;
             } else if (s->mem[0] == buf[0] &&
                        s->mem[2] == buf[1] &&
                        s->mem[4] == buf[2] &&
-...
                        s->mem[10] == buf[5]) {
                 /* match */
             } else {
                 return;
                 return size;
+            }
+        }
-...
         /* now we can signal we have received something */
         s->isr |= ENISR_RX;
         ne2000_update_irq(s);
         return size_;
+    }
     static void ne2000_ioport_write(void *opaque, uint32_t addr, uint32_t val)

     #define MIN_BUF_SIZE 60
     static void pcnet_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
     static ssize_t pcnet_receive(VLANClientState *vc, const uint8_t *buf, size_t size_)
+    {
         PCNetState *s = vc->opaque;
         int is_padr = 0, is_bcast = 0, is_ladr = 0;
         uint8_t buf1[60];
         int remaining;
         int crc_err = 0;
         int size = size_;
         if (CSR_DRX(s) || CSR_STOP(s) || CSR_SPND(s) || !size)
             return;
             return -1;
     #ifdef PCNET_DEBUG
         printf("pcnet_receive size=%d\n", size);
-...
         pcnet_poll(s);
         pcnet_update_irq(s);
         return size_;
+    }
     static void pcnet_transmit(PCNetState *s)

b/hw/rtl8139.c
812	812	}
813	813	}
814	814
815		static void rtl8139_do_receive(VLANClientState vc, const uint8_t buf, int size, int do_interrupt)
	815	static ssize_t rtl8139_do_receive(VLANClientState vc, const uint8_t buf, size_t size_, int do_interrupt)
816	816	{
817	817	RTL8139State *s = vc->opaque;
	818	int size = size_;
818	819
819	820	uint32_t packet_header = 0;
820	821
...	...
828	829	if (!s->clock_enabled)
829	830	{
830	831	DEBUG_PRINT(("RTL8139: stopped ==========================\n"));
831		return;
	832	return -1;
832	833	}
833	834
834	835	/* first check if receiver is enabled */
...	...
836	837	if (!rtl8139_receiver_enabled(s))
837	838	{
838	839	DEBUG_PRINT(("RTL8139: receiver disabled ================\n"));
839		return;
	840	return -1;
840	841	}
841	842
842	843	/* XXX: check this */
...	...
854	855	/* update tally counter */
855	856	++s->tally_counters.RxERR;
856	857
857		return;
	858	return size;
858	859	}
859	860
860	861	packet_header \|= RxBroadcast;
...	...
873	874	/* update tally counter */
874	875	++s->tally_counters.RxERR;
875	876
876		return;
	877	return size;
877	878	}
878	879
879	880	int mcast_idx = compute_mcast_idx(buf);
...	...
885	886	/* update tally counter */
886	887	++s->tally_counters.RxERR;
887	888
888		return;
	889	return size;
889	890	}
890	891
891	892	packet_header \|= RxMulticast;
...	...
909	910	/* update tally counter */
910	911	++s->tally_counters.RxERR;
911	912
912		return;
	913	return size;
913	914	}
914	915
915	916	packet_header \|= RxPhysical;
...	...
926	927	/* update tally counter */
927	928	++s->tally_counters.RxERR;
928	929
929		return;
	930	return size;
930	931	}
931	932	}
932	933
...	...
993	994	++s->tally_counters.MissPkt;
994	995
995	996	rtl8139_update_irq(s);
996		return;
	997	return size_;
997	998	}
998	999
999	1000	uint32_t rx_space = rxdw0 & CP_RX_BUFFER_SIZE_MASK;
...	...
1013	1014	++s->tally_counters.MissPkt;
1014	1015
1015	1016	rtl8139_update_irq(s);
1016		return;
	1017	return size_;
1017	1018	}
1018	1019
1019	1020	target_phys_addr_t rx_addr = rtl8139_addr64(rxbufLO, rxbufHI);
...	...
1118	1119	s->IntrStatus \|= RxOverflow;
1119	1120	++s->RxMissed;
1120	1121	rtl8139_update_irq(s);
1121		return;
	1122	return size_;
1122	1123	}
1123	1124
1124	1125	packet_header \|= RxStatusOK;
...	...
1156	1157	{
1157	1158	rtl8139_update_irq(s);
1158	1159	}
	1160
	1161	return size_;
1159	1162	}
1160	1163
1161		static void rtl8139_receive(VLANClientState vc, const uint8_t buf, size_t size)
	1164	static ssize_t rtl8139_receive(VLANClientState vc, const uint8_t buf, size_t size)
1162	1165	{
1163		rtl8139_do_receive(vc, buf, size, 1);
	1166	return rtl8139_do_receive(vc, buf, size, 1);
1164	1167	}
1165	1168
1166	1169	static void rtl8139_reset_rxring(RTL8139State *s, uint32_t bufferSize)

         return 1;
+    }
     static void smc91c111_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
     static ssize_t smc91c111_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
+    {
         smc91c111_state *s = vc->opaque;
         int status;
-...
         uint8_t *p;
         if ((s->rcr & RCR_RXEN) == 0 || (s->rcr & RCR_SOFT_RST))
             return;
             return -1;
         /* Short packets are padded with zeros.  Receiving a packet
            < 64 bytes long is considered an error condition.  */
         if (size < 64)
-...
             packetsize += 4;
         /* TODO: Flag overrun and receive errors.  */
         if (packetsize > 2048)
             return;
             return -1;
         packetnum = smc91c111_allocate_packet(s);
         if (packetnum == 0x80)
             return;
             return -1;
         s->rx_fifo[s->rx_fifo_len++] = packetnum;
         p = &s->data[packetnum][0];
-...
         /* TODO: Raise early RX interrupt?  */
         s->int_level |= INT_RCV;
         smc91c111_update(s);
         return size;
+    }
     static CPUReadMemoryFunc *smc91c111_readfn[] = {

+    }
     /* TODO: Implement MAC address filtering.  */
     static void stellaris_enet_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
     static ssize_t stellaris_enet_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
+    {
         stellaris_enet_state *s = vc->opaque;
         int n;
-...
         uint32_t crc;
         if ((s->rctl & SE_RCTL_RXEN) == 0)
             return;
             return -1;
         if (s->np >= 31) {
             DPRINTF("Packet dropped\n");
             return;
             return -1;
+        }
         DPRINTF("Received packet len=%d\n", size);
-...
         s->ris |= SE_INT_RX;
         stellaris_enet_update(s);
         return size;
+    }
     static int stellaris_enet_can_receive(VLANClientState *vc)

         return ret;
+    }
     static void usbnet_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
     static ssize_t usbnet_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
+    {
         USBNetState *s = vc->opaque;
         struct rndis_packet_msg_type *msg;
-...
         if (s->rndis) {
             msg = (struct rndis_packet_msg_type *) s->in_buf;
             if (!s->rndis_state == RNDIS_DATA_INITIALIZED)
                 return;
                 return -1;
             if (size + sizeof(struct rndis_packet_msg_type) > sizeof(s->in_buf))
                 return;
                 return -1;
             memset(msg, 0, sizeof(struct rndis_packet_msg_type));
             msg->MessageType = cpu_to_le32(RNDIS_PACKET_MSG);
-...
             s->in_len = size + sizeof(struct rndis_packet_msg_type);
         } else {
             if (size > sizeof(s->in_buf))
                 return;
                 return -1;
             memcpy(s->in_buf, buf, size);
             s->in_len = size;
+        }
         s->in_ptr = 0;
         return size;
+    }
     static int usbnet_can_receive(VLANClientState *vc)

         return 0;
+    }
     static void virtio_net_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
     static ssize_t virtio_net_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
+    {
         VirtIONet *n = vc->opaque;
         struct virtio_net_hdr_mrg_rxbuf *mhdr = NULL;
         size_t hdr_len, offset, i;
         if (!do_virtio_net_can_receive(n, size))
             return;
             return -1;
         if (!receive_filter(n, buf, size))
             return;
             return size;
         /* hdr_len refers to the header we supply to the guest */
         hdr_len = n->mergeable_rx_bufs ?
-...
             if ((i != 0 && !n->mergeable_rx_bufs) ||
                 virtqueue_pop(n->rx_vq, &elem) == 0) {
                 if (i == 0)
                     return;
                     return -1;
                 fprintf(stderr, "virtio-net truncating packet\n");
                 exit(1);
+            }
-...
         virtqueue_flush(n->rx_vq, i);
         virtio_notify(&n->vdev, n->rx_vq);
         return size;
+    }
     /* TX */

         return 1;
+    }
     static void net_rx_packet(VLANClientState *vc, const uint8_t *buf, size_t size)
     static ssize_t net_rx_packet(VLANClientState *vc, const uint8_t *buf, size_t size)
+    {
         struct XenNetDev *netdev = vc->opaque;
         netif_rx_request_t rxreq;
-...
         void *page;
         if (netdev->xendev.be_state != XenbusStateConnected)
     	return;
     	return -1;
         rc = netdev->rx_ring.req_cons;
         rp = netdev->rx_ring.sring->req_prod;
-...
         if (rc == rp || RING_REQUEST_CONS_OVERFLOW(&netdev->rx_ring, rc)) {
     	xen_be_printf(&netdev->xendev, 2, "no buffer, drop packet\n");
     	return;
     	return -1;
+        }
         if (size > XC_PAGE_SIZE - NET_IP_ALIGN) {
     	xen_be_printf(&netdev->xendev, 0, "packet too big (%lu > %ld)",
     		      (unsigned long)size, XC_PAGE_SIZE - NET_IP_ALIGN);
     	return;
     	return -1;
+        }
         memcpy(&rxreq, RING_GET_REQUEST(&netdev->rx_ring, rc), sizeof(rxreq));
-...
     	xen_be_printf(&netdev->xendev, 0, "error: rx gref dereference failed (%d)\n",
                           rxreq.gref);
     	net_rx_response(netdev, &rxreq, NETIF_RSP_ERROR, 0, 0, 0);
     	return;
     	return -1;
+        }
         memcpy(page + NET_IP_ALIGN, buf, size);
         xc_gnttab_munmap(netdev->xendev.gnttabdev, page, 1);
         net_rx_response(netdev, &rxreq, NETIF_RSP_OKAY, NET_IP_ALIGN, size, 0);
         return size;
+    }
     /* ------------------------------------------------------------- */

         return slirp_inited;
+    }
     static void slirp_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
     static ssize_t slirp_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
+    {
     #ifdef DEBUG_SLIRP
         printf("slirp input:\n");
         hex_dump(stdout, buf, size);
     #endif
         slirp_input(buf, size);
         return size;
+    }
     static int slirp_in_use;
-...
         return len;
+    }
     static void tap_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
     static ssize_t tap_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
+    {
         TAPState *s = vc->opaque;
         int ret;
         for(;;) {
             ret = write(s->fd, buf, size);
             if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
             } else {
                 break;
+            }
+        }
         ssize_t len;
         do {
             len = write(s->fd, buf, size);
         } while (len == -1 && (errno == EINTR || errno == EAGAIN));
         return len;
+    }
     static int tap_can_send(void *opaque)
-...
+        }
+    }
     static void vde_receive(VLANClientState *vc, const uint8_t *buf, int size)
     static ssize_t vde_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
+    {
         VDEState *s = vc->opaque;
         int ret;
         for(;;) {
             ret = vde_send(s->vde, (const char *)buf, size, 0);
             if (ret < 0 && errno == EINTR) {
             } else {
                 break;
+            }
+        }
         ssize ret;
         do {
           ret = vde_send(s->vde, (const char *)buf, size, 0);
         } while (ret < 0 && errno == EINTR);
         return ret;
+    }
     static void vde_cleanup(VLANClientState *vc)
-...
     } NetSocketListenState;
     /* XXX: we consider we can send the whole packet without blocking */
     static void net_socket_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
     static ssize_t net_socket_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
+    {
         NetSocketState *s = vc->opaque;
         uint32_t len;
         len = htonl(size);
         send_all(s->fd, (const uint8_t *)&len, sizeof(len));
         send_all(s->fd, buf, size);
         return send_all(s->fd, buf, size);
+    }
     static void net_socket_receive_dgram(VLANClientState *vc, const uint8_t *buf, size_t size)
     static ssize_t net_socket_receive_dgram(VLANClientState *vc, const uint8_t *buf, size_t size)
+    {
         NetSocketState *s = vc->opaque;
         sendto(s->fd, buf, size, 0,
                (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
         return sendto(s->fd, buf, size, 0,
                       (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
+    }
     static void net_socket_send(void *opaque)
-...
         uint32_t len;
     };
     static void dump_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
     static ssize_t dump_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
+    {
         DumpState *s = vc->opaque;
         struct pcap_sf_pkthdr hdr;
-...
         /* Early return in case of previous error. */
         if (s->fd < 0) {
             return;
             return size;
+        }
         ts = muldiv64(qemu_get_clock(vm_clock), 1000000, ticks_per_sec);
-...
             close(s->fd);
             s->fd = -1;
+        }
         return size;
+    }
     static void net_dump_cleanup(VLANClientState *vc)

     typedef struct VLANClientState VLANClientState;
     typedef int (NetCanReceive)(VLANClientState *);
     typedef void (NetReceive)(VLANClientState *, const uint8_t *, size_t);
     typedef ssize_t (NetReceive)(VLANClientState *, const uint8_t *, size_t);
     typedef ssize_t (NetReceiveIOV)(VLANClientState *, const struct iovec *, int);
     typedef void (NetCleanup) (VLANClientState *);
     typedef void (LinkStatusChanged)(VLANClientState *);

b/tap-win32.c
650	650	qemu_free(s);
651	651	}
652	652
653		static void tap_receive(VLANClientState vc, const uint8_t buf, size_t size)
	653	static ssize_t tap_receive(VLANClientState vc, const uint8_t buf, size_t size)
654	654	{
655		TAPState *s = opaque;
	655	TAPState *s = vc->opaque;
656	656
657		tap_win32_write(s->handle, buf, size);
	657	return tap_win32_write(s->handle, buf, size);
658	658	}
659	659
660	660	static void tap_win32_send(void *opaque)

Archipelago » qemu

Revision 4f1c942b