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);
}
