void ethernet_trigger (struct netdriverdata *ndd, void *vsd) { if (!ndd) return; switch (ndd->type) { case UAENET_SLIRP: case UAENET_SLIRP_INBOUND: { struct ethernet_data *ed = (struct ethernet_data*)vsd; if (slirp_data) { uae_u8 pkt[4000]; int len = sizeof pkt; int v; uae_sem_wait (&slirp_sem1); v = slirp_data->getfunc(ed->userdata, pkt, &len); uae_sem_post (&slirp_sem1); if (v) { uae_sem_wait (&slirp_sem2); slirp_input(pkt, len); uae_sem_post (&slirp_sem2); } } } return; #ifdef WITH_UAENET_PCAP case UAENET_PCAP: uaenet_trigger (vsd); return; #endif } }
co_rc_t co_win32_overlapped_read_received(co_win32_overlapped_t *overlapped) { if (overlapped == &daemon_overlapped) { /* Received packet from daemon */ co_message_t *message; char * buffer = overlapped->buffer; long size_left = overlapped->size; unsigned long message_size; do { message = (co_message_t *)buffer; message_size = message->size + sizeof (co_message_t); buffer += message_size; size_left -= message_size; /* Check buffer overrun */ if (size_left < 0) { co_debug("Error: Message incomplete (%ld)\n", size_left); return CO_RC(ERROR); } profile_me("to slirp"); WaitForSingleObject(slirp_mutex, INFINITE); slirp_input(message->data, message->size); ReleaseMutex(slirp_mutex); } while (size_left > 0); } return CO_RC(OK); }
void enet_slirp_input(Uint8 *pkt, int pkt_len) { if (slirp_inited) { Log_Printf(LOG_WARN, "[SLIRP] Input packet with %i bytes",enet_tx_buffer.size); SDL_LockMutex(slirp_mutex); slirp_input(pkt,pkt_len); SDL_UnlockMutex(slirp_mutex); } }
static VMIOS_INTERCEPT_FN(netTxPacket) { Uns32 addr, bytes; getArg(processor, object, 0, &addr); getArg(processor, object, 1, &bytes); // copy data from PSE to host memory space. Uns8 packet[bytes]; vmirtReadNByteDomain(object->domain, addr, packet, bytes, NULL, False); if(DIAG_HIGH) vmiMessage("I", PREFIX, "netTxPacket bytes:%d", bytes); // send to slirp slirp_input(object->slirp, packet, bytes); }
static unsigned int WINAPI ether_thread_write_packets(void *arg) { LPPACKET Packet; thread_active_1 = true; D(bug("ether_thread_write_packets start\n")); while(thread_active) { // must be alertable, otherwise write completion is never called WaitForSingleObjectEx(int_send_now,INFINITE,TRUE); while( thread_active && (Packet = get_send_head()) != 0 ) { switch (net_if_type) { case NET_IF_ROUTER: if(router_write_packet((uint8 *)Packet->Buffer, Packet->Length)) { Packet->bIoComplete = TRUE; recycle_write_packet(Packet); } break; case NET_IF_FAKE: Packet->bIoComplete = TRUE; recycle_write_packet(Packet); break; case NET_IF_B2ETHER: if(!PacketSendPacket( fd, Packet, FALSE, TRUE )) { // already recycled if async } break; case NET_IF_TAP: if (!tap_send_packet(fd, Packet, FALSE, TRUE)) { // already recycled if async } break; case NET_IF_SLIRP: slirp_input((uint8 *)Packet->Buffer, Packet->Length); Packet->bIoComplete = TRUE; recycle_write_packet(Packet); break; } } } D(bug("ether_thread_write_packets exit\n")); thread_active_1 = false; return(0); }
void uae_slirp_input(const uint8_t *pkt, int pkt_len) { #ifdef WITH_QEMU_SLIRP if (impl == QEMU_IMPLEMENTATION) { if (qemu_uae_slirp_input) { qemu_uae_slirp_input(pkt, pkt_len); } return; } #endif #ifdef WITH_BUILTIN_SLIRP if (impl == BUILTIN_IMPLEMENTATION) { slirp_input(pkt, pkt_len); return; } #endif }
co_rc_t co_win32_overlapped_read_received(co_win32_overlapped_t *overlapped) { if (overlapped == &daemon_overlapped) { /* Received packet from daemon */ co_message_t *message; message = (co_message_t *)overlapped->buffer; profile_me("to slirp"); WaitForSingleObject(slirp_mutex, INFINITE); slirp_input(message->data, message->size); ReleaseMutex(slirp_mutex); } return CO_RC(OK); }
void sim_slirp_dispatch (SLIRP *slirp) { struct slirp_write_request *request; /* first deliver any transmit packets which are pending */ pthread_mutex_lock (&slirp->write_buffer_lock); while (NULL != (request = slirp->write_requests)) { /* Pull buffer off request list */ slirp->write_requests = request->next; pthread_mutex_unlock (&slirp->write_buffer_lock); slirp_input (slirp->slirp, (const uint8_t *)request->msg, (int)request->len); pthread_mutex_lock (&slirp->write_buffer_lock); /* Put buffer on free buffer list */ request->next = slirp->write_buffers; slirp->write_buffers = request; } pthread_mutex_unlock (&slirp->write_buffer_lock); slirp_pollfds_poll(slirp->gpollfds, 0); }