BasiliskII/src/ether.cpp

/*
 *  ether.cpp - Ethernet device driver
 *
 *  Basilisk II (C) 1997-2001 Christian Bauer
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/*
 *  SEE ALSO
 *    Inside Macintosh: Devices, chapter 1 "Device Manager"
 *    Inside Macintosh: Networking, chapter 11 "Ethernet, Token Ring, and FDDI"
 *    Inside AppleTalk, chapter 3 "Ethernet and TokenTalk Link Access Protocols"
 */

#include "sysdeps.h"

#include <string.h>
#include <map>

#if SUPPORTS_UDP_TUNNEL
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <netdb.h>
#include <errno.h>
#endif

#include "cpu_emulation.h"
#include "main.h"
#include "macos_util.h"
#include "emul_op.h"
#include "prefs.h"
#include "ether.h"
#include "ether_defs.h"

#ifndef NO_STD_NAMESPACE
using std::map;
#endif

#define DEBUG 0
#include "debug.h"

#define MONITOR 0


// Global variables
uint8 ether_addr[6];                    // Ethernet address (set by ether_init())
static bool net_open = false;   // Flag: initialization succeeded, network device open (set by EtherInit())

static bool udp_tunnel = false; // Flag: tunnelling AppleTalk over UDP using BSD socket API
static uint16 udp_port;
static int udp_socket = -1;

// Mac address of driver data in MacOS RAM
uint32 ether_data = 0;

// Attached network protocols for UDP tunneling, maps protocol type to MacOS handler address
static map<uint16, uint32> udp_protocols;


/*
 *  Initialization
 */

void EtherInit(void)
{
        net_open = false;
        udp_tunnel = false;

#if SUPPORTS_UDP_TUNNEL
        // UDP tunnelling requested?
        if (PrefsFindBool("udptunnel")) {
                udp_tunnel = true;
                udp_port = PrefsFindInt32("udpport");

                // Open UDP socket
                udp_socket = socket(PF_INET, SOCK_DGRAM, 0);
                if (udp_socket < 0) {
                        perror("socket");
                        return;
                }

                // Bind to specified address and port
                struct sockaddr_in sa;
                memset(&sa, 0, sizeof(sa));
                sa.sin_family = AF_INET;
                sa.sin_addr.s_addr = INADDR_ANY;
                sa.sin_port = htons(udp_port);
                if (bind(udp_socket, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
                        perror("bind");
                        close(udp_socket);
                        udp_socket = -1;
                        return;
                }

                // Retrieve local IP address (or at least one of them)
                socklen_t sa_len = sizeof(sa);
                getsockname(udp_socket, (struct sockaddr *)&sa, &sa_len);
                uint32 udp_ip = sa.sin_addr.s_addr;
                if (udp_ip == INADDR_ANY || udp_ip == INADDR_LOOPBACK) {
                        char name[256];
                        gethostname(name, sizeof(name));
                        struct hostent *local = gethostbyname(name);
                        if (local)
                                udp_ip = *(uint32 *)local->h_addr_list[0];
                }
                udp_ip = ntohl(udp_ip);

                // Construct dummy Ethernet address from local IP address
                ether_addr[0] = 'B';
                ether_addr[1] = '2';
                ether_addr[2] = udp_ip >> 24;
                ether_addr[3] = udp_ip >> 16;
                ether_addr[4] = udp_ip >> 8;
                ether_addr[5] = udp_ip;
                D(bug("Ethernet address %02x %02x %02x %02x %02x %02x\n", ether_addr[0], ether_addr[1], ether_addr[2], ether_addr[3], ether_addr[4], ether_addr[5]));

                // Set socket options
                int on = 1;
                setsockopt(udp_socket, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on));
                ioctl(udp_socket, FIONBIO, &on);

                // Start thread for packet reception
                if (!ether_start_udp_thread(udp_socket)) {
                        close(udp_socket);
                        udp_socket = -1;
                        return;
                }

                net_open = true;
        } else
#endif
                if (ether_init())
                        net_open = true;
}


/*
 *  Deinitialization
 */

void EtherExit(void)
{
        if (net_open) {
#if SUPPORTS_UDP_TUNNEL
                if (udp_tunnel) {
                        if (udp_socket >= 0) {
                                ether_stop_udp_thread();
                                close(udp_socket);
                                udp_socket = -1;
                        }
                } else
#endif
                        ether_exit();
                net_open = false;
        }
}


/*
 *  Reset
 */

void EtherReset(void)
{
        udp_protocols.clear();
        ether_reset();
}


/*
 *  Check whether Ethernet address is AppleTalk broadcast address
 */

static inline bool is_apple_talk_broadcast(uint8 *p)
{
        return p[0] == 0x09 && p[1] == 0x00 && p[2] == 0x07
            && p[3] == 0xff && p[4] == 0xff && p[5] == 0xff;
}


/*
 *  Driver Open() routine
 */

int16 EtherOpen(uint32 pb, uint32 dce)
{
        D(bug("EtherOpen\n"));

        // Allocate driver data
        M68kRegisters r;
        r.d[0] = SIZEOF_etherdata;
        Execute68kTrap(0xa71e, &r);             // NewPtrSysClear()
        if (r.a[0] == 0)
                return openErr;
        ether_data = r.a[0];
        D(bug(" data %08x\n", ether_data));

        WriteMacInt16(ether_data + ed_DeferredTask + qType, dtQType);
        WriteMacInt32(ether_data + ed_DeferredTask + dtAddr, ether_data + ed_Code);
        WriteMacInt32(ether_data + ed_DeferredTask + dtParam, ether_data + ed_Result);
                                                                                                                        // Deferred function for signalling that packet write is complete (pointer to mydtResult in a1)
        WriteMacInt16(ether_data + ed_Code, 0x2019);                    //  move.l      (a1)+,d0        (result)
        WriteMacInt16(ether_data + ed_Code + 2, 0x2251);                //  move.l      (a1),a1         (dce)
        WriteMacInt32(ether_data + ed_Code + 4, 0x207808fc);    //  move.l      JIODone,a0
        WriteMacInt16(ether_data + ed_Code + 8, 0x4ed0);                //  jmp         (a0)

        WriteMacInt32(ether_data + ed_DCE, dce);
                                                                                                                        // ReadPacket/ReadRest routines
        WriteMacInt16(ether_data + ed_ReadPacket, 0x6010);              //      bra             2
        WriteMacInt16(ether_data + ed_ReadPacket + 2, 0x3003);  //  move.w      d3,d0
        WriteMacInt16(ether_data + ed_ReadPacket + 4, 0x9041);  //  sub.w       d1,d0
        WriteMacInt16(ether_data + ed_ReadPacket + 6, 0x4a43);  //  tst.w       d3
        WriteMacInt16(ether_data + ed_ReadPacket + 8, 0x6702);  //  beq         1
        WriteMacInt16(ether_data + ed_ReadPacket + 10, M68K_EMUL_OP_ETHER_READ_PACKET);
        WriteMacInt16(ether_data + ed_ReadPacket + 12, 0x3600); //1 move.w      d0,d3
        WriteMacInt16(ether_data + ed_ReadPacket + 14, 0x7000); //  moveq       #0,d0
        WriteMacInt16(ether_data + ed_ReadPacket + 16, 0x4e75); //  rts
        WriteMacInt16(ether_data + ed_ReadPacket + 18, M68K_EMUL_OP_ETHER_READ_PACKET); //2
        WriteMacInt16(ether_data + ed_ReadPacket + 20, 0x4a43); //  tst.w       d3
        WriteMacInt16(ether_data + ed_ReadPacket + 22, 0x4e75); //  rts
        return 0;
}


/*
 *  Driver Control() routine
 */

int16 EtherControl(uint32 pb, uint32 dce)
{
        uint16 code = ReadMacInt16(pb + csCode);
        D(bug("EtherControl %d\n", code));
        switch (code) {
                case 1:                                 // KillIO
                        return -1;

                case kENetAddMulti:             // Add multicast address
                        D(bug(" AddMulti %08x%04x\n", ReadMacInt32(pb + eMultiAddr), ReadMacInt16(pb + eMultiAddr + 4)));
                        if (net_open && !udp_tunnel)
                                return ether_add_multicast(pb);
                        return noErr;

                case kENetDelMulti:             // Delete multicast address
                        D(bug(" DelMulti %08x%04x\n", ReadMacInt32(pb + eMultiAddr), ReadMacInt16(pb + eMultiAddr + 4)));
                        if (net_open && !udp_tunnel)
                                return ether_del_multicast(pb);
                        return noErr;

                case kENetAttachPH: {   // Attach protocol handler
                        uint16 type = ReadMacInt16(pb + eProtType);
                        uint32 handler = ReadMacInt32(pb + ePointer);
                        D(bug(" AttachPH prot %04x, handler %08x\n", type, handler));
                        if (net_open) {
                                if (udp_tunnel) {
                                        if (udp_protocols.find(type) != udp_protocols.end())
                                                return lapProtErr;
                                        udp_protocols[type] = handler;
                                } else
                                        return ether_attach_ph(type, handler);
                        }
                        return noErr;
                }

                case kENetDetachPH: {   // Detach protocol handler
                        uint16 type = ReadMacInt16(pb + eProtType);
                        D(bug(" DetachPH prot %04x\n", type));
                        if (net_open) {
                                if (udp_tunnel) {
                                        if (udp_protocols.erase(type) == 0)
                                                return lapProtErr;
                                } else
                                        return ether_detach_ph(type);
                        }
                        return noErr;
                }

                case kENetWrite: {              // Transmit raw Ethernet packet
                        uint32 wds = ReadMacInt32(pb + ePointer);
                        D(bug(" EtherWrite\n"));
                        if (ReadMacInt16(wds) < 14)
                                return eLenErr; // Header incomplete
                        if (net_open) {
#if SUPPORTS_UDP_TUNNEL
                                if (udp_tunnel) {

                                        // Copy packet to buffer
                                        uint8 packet[1514];
                                        int len = ether_wds_to_buffer(wds, packet);

                                        // Set source address and extract destination address
                                        memcpy(packet + 6, ether_addr, 6);
                                        uint32 dest_ip;
                                        if (packet[0] == 'B' && packet[1] == '2')
                                                dest_ip = (packet[2] << 24) | (packet[3] << 16) | (packet[4] << 8) | packet[5];
                                        else if (is_apple_talk_broadcast(packet))
                                                dest_ip = INADDR_BROADCAST;
                                        else
                                                return eMultiErr;

#if MONITOR
                                        bug("Sending Ethernet packet:\n");
                                        for (int i=0; i<len; i++) {
                                                bug("%02x ", packet[i]);
                                        }
                                        bug("\n");
#endif

                                        // Send packet
                                        struct sockaddr_in sa;
                                        sa.sin_family = AF_INET;
                                        sa.sin_addr.s_addr = htonl(dest_ip);
                                        sa.sin_port = htons(udp_port);
                                        if (sendto(udp_socket, packet, len, 0, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
                                                D(bug("WARNING: Couldn't transmit packet\n"));
                                                return excessCollsns;
                                        }
                                } else
#endif
                                        return ether_write(wds);
                        }
                        return noErr;
                }

                case kENetGetInfo: {    // Get device information/statistics
                        D(bug(" GetInfo buf %08x, size %d\n", ReadMacInt32(pb + ePointer), ReadMacInt16(pb + eBuffSize)));

                        // Collect info (only ethernet address)
                        uint8 buf[18];
                        memset(buf, 0, 18);
                        memcpy(buf, ether_addr, 6);

                        // Transfer info to supplied buffer
                        int16 size = ReadMacInt16(pb + eBuffSize);
                        if (size > 18)
                                size = 18;
                        WriteMacInt16(pb + eDataSize, size);    // Number of bytes actually written
                        Host2Mac_memcpy(ReadMacInt32(pb + ePointer), buf, size);
                        return noErr;
                }

                case kENetSetGeneral:   // Set general mode (always in general mode)
                        D(bug(" SetGeneral\n"));
                        return noErr;

                default:
                        printf("WARNING: Unknown EtherControl(%d)\n", code);
                        return controlErr;
        }
}


/*
 *  Ethernet ReadPacket routine
 */

void EtherReadPacket(uint8 **src, uint32 &dest, uint32 &len, uint32 &remaining)
{
        D(bug("EtherReadPacket src %p, dest %08x, len %08x, remaining %08x\n", *src, dest, len, remaining));
        uint32 todo = len > remaining ? remaining : len;
        Host2Mac_memcpy(dest, *src, todo);
        *src += todo;
        dest += todo;
        len -= todo;
        remaining -= todo;
}


#if SUPPORTS_UDP_TUNNEL
/*
 *  Read packet from UDP socket
 */

void ether_udp_read(uint8 *packet, int length, struct sockaddr_in *from)
{
        // Drop packets sent by us
        if (memcmp(packet + 6, ether_addr, 6) == 0)
                return;

#if MONITOR
        bug("Receiving Ethernet packet:\n");
        for (int i=0; i<length; i++) {
                bug("%02x ", packet[i]);
        }
        bug("\n");
#endif

        // Get packet type
        uint16 type = (packet[12] << 8) | packet[13];

        // Look for protocol
        uint16 search_type = (type <= 1500 ? 0 : type);
        if (udp_protocols.find(search_type) == udp_protocols.end())
                return;
        uint32 handler = udp_protocols[search_type];
        if (handler == 0)
                return;

        // Copy header to RHA
        Host2Mac_memcpy(ether_data + ed_RHA, packet, 14);
        D(bug(" header %08x%04x %08x%04x %04x\n", ReadMacInt32(ether_data + ed_RHA), ReadMacInt16(ether_data + ed_RHA + 4), ReadMacInt32(ether_data + ed_RHA + 6), ReadMacInt16(ether_data + ed_RHA + 10), ReadMacInt16(ether_data + ed_RHA + 12)));

        // Call protocol handler
        M68kRegisters r;
        r.d[0] = type;                                                                  // Packet type
        r.d[1] = length - 14;                                                   // Remaining packet length (without header, for ReadPacket)
        r.a[0] = (uint32)packet + 14;                                   // Pointer to packet (host address, for ReadPacket)
        r.a[3] = ether_data + ed_RHA + 14;                              // Pointer behind header in RHA
        r.a[4] = ether_data + ed_ReadPacket;                    // Pointer to ReadPacket/ReadRest routines
        D(bug(" calling protocol handler %08x, type %08x, length %08x, data %08x, rha %08x, read_packet %08x\n", handler, r.d[0], r.d[1], r.a[0], r.a[3], r.a[4]));
        Execute68k(handler, &r);
}
#endif
Revision:	1.6
Committed:	2001-07-13T15:39:21Z (23 years ago) by cebix
Branch:	MAIN
Changes since 1.5:	+21 -10 lines
Log Message:	- updated the TECH document - EtherReset() clears the UDP protocol list - audio_oss_esd.cpp: AudioExit() calls close_audio() - ether_unix.cpp: uses map<> for protocol handlers - updated audio_dummy.cpp and ether_dummy.cpp
#	User	Rev	Content
1	cebix	1.1	/*
2			* ether.cpp - Ethernet device driver
3			*
4	cebix	1.4	* Basilisk II (C) 1997-2001 Christian Bauer
5	cebix	1.1	*
6			* This program is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19			*/
20
21			/*
22			* SEE ALSO
23			* Inside Macintosh: Devices, chapter 1 "Device Manager"
24			* Inside Macintosh: Networking, chapter 11 "Ethernet, Token Ring, and FDDI"
25			* Inside AppleTalk, chapter 3 "Ethernet and TokenTalk Link Access Protocols"
26			*/
27
28	cebix	1.6	#include "sysdeps.h"
29
30	cebix	1.1	#include <string.h>
31	cebix	1.6	#include <map>
32	cebix	1.1
33	cebix	1.5	#if SUPPORTS_UDP_TUNNEL
34			#include <netinet/in.h>
35			#include <sys/socket.h>
36			#include <sys/ioctl.h>
37			#include <netdb.h>
38			#include <errno.h>
39			#endif
40
41	cebix	1.6	#include "cpu_emulation.h"
42			#include "main.h"
43			#include "macos_util.h"
44			#include "emul_op.h"
45			#include "prefs.h"
46			#include "ether.h"
47			#include "ether_defs.h"
48	cebix	1.5
49			#ifndef NO_STD_NAMESPACE
50			using std::map;
51			#endif
52
53	cebix	1.1	#define DEBUG 0
54			#include "debug.h"
55
56	cebix	1.5	#define MONITOR 0
57
58	cebix	1.1
59			// Global variables
60	cebix	1.5	uint8 ether_addr[6]; // Ethernet address (set by ether_init())
61			static bool net_open = false; // Flag: initialization succeeded, network device open (set by EtherInit())
62
63			static bool udp_tunnel = false; // Flag: tunnelling AppleTalk over UDP using BSD socket API
64			static uint16 udp_port;
65			static int udp_socket = -1;
66
67			// Mac address of driver data in MacOS RAM
68			uint32 ether_data = 0;
69	cebix	1.1
70	cebix	1.5	// Attached network protocols for UDP tunneling, maps protocol type to MacOS handler address
71			static map<uint16, uint32> udp_protocols;
72
73
74			/*
75			* Initialization
76			*/
77
78			void EtherInit(void)
79			{
80			net_open = false;
81			udp_tunnel = false;
82
83			#if SUPPORTS_UDP_TUNNEL
84			// UDP tunnelling requested?
85			if (PrefsFindBool("udptunnel")) {
86			udp_tunnel = true;
87			udp_port = PrefsFindInt32("udpport");
88
89			// Open UDP socket
90			udp_socket = socket(PF_INET, SOCK_DGRAM, 0);
91			if (udp_socket < 0) {
92			perror("socket");
93			return;
94			}
95
96			// Bind to specified address and port
97			struct sockaddr_in sa;
98			memset(&sa, 0, sizeof(sa));
99			sa.sin_family = AF_INET;
100			sa.sin_addr.s_addr = INADDR_ANY;
101			sa.sin_port = htons(udp_port);
102			if (bind(udp_socket, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
103			perror("bind");
104			close(udp_socket);
105			udp_socket = -1;
106			return;
107			}
108
109			// Retrieve local IP address (or at least one of them)
110			socklen_t sa_len = sizeof(sa);
111			getsockname(udp_socket, (struct sockaddr *)&sa, &sa_len);
112			uint32 udp_ip = sa.sin_addr.s_addr;
113			if (udp_ip == INADDR_ANY \|\| udp_ip == INADDR_LOOPBACK) {
114			char name[256];
115			gethostname(name, sizeof(name));
116			struct hostent *local = gethostbyname(name);
117			if (local)
118			udp_ip = (uint32 )local->h_addr_list[0];
119			}
120			udp_ip = ntohl(udp_ip);
121
122			// Construct dummy Ethernet address from local IP address
123			ether_addr[0] = 'B';
124			ether_addr[1] = '2';
125			ether_addr[2] = udp_ip >> 24;
126			ether_addr[3] = udp_ip >> 16;
127			ether_addr[4] = udp_ip >> 8;
128			ether_addr[5] = udp_ip;
129			D(bug("Ethernet address %02x %02x %02x %02x %02x %02x\n", ether_addr[0], ether_addr[1], ether_addr[2], ether_addr[3], ether_addr[4], ether_addr[5]));
130
131			// Set socket options
132			int on = 1;
133			setsockopt(udp_socket, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on));
134			ioctl(udp_socket, FIONBIO, &on);
135
136			// Start thread for packet reception
137			if (!ether_start_udp_thread(udp_socket)) {
138			close(udp_socket);
139			udp_socket = -1;
140			return;
141			}
142
143			net_open = true;
144			} else
145			#endif
146			if (ether_init())
147			net_open = true;
148			}
149
150
151			/*
152			* Deinitialization
153			*/
154
155			void EtherExit(void)
156			{
157			if (net_open) {
158			#if SUPPORTS_UDP_TUNNEL
159			if (udp_tunnel) {
160			if (udp_socket >= 0) {
161			ether_stop_udp_thread();
162			close(udp_socket);
163			udp_socket = -1;
164			}
165			} else
166			#endif
167			ether_exit();
168			net_open = false;
169			}
170	cebix	1.6	}
171
172
173			/*
174			* Reset
175			*/
176
177			void EtherReset(void)
178			{
179			udp_protocols.clear();
180			ether_reset();
181	cebix	1.5	}
182
183
184			/*
185			* Check whether Ethernet address is AppleTalk broadcast address
186			*/
187
188			static inline bool is_apple_talk_broadcast(uint8 *p)
189			{
190			return p[0] == 0x09 && p[1] == 0x00 && p[2] == 0x07
191			&& p[3] == 0xff && p[4] == 0xff && p[5] == 0xff;
192			}
193	cebix	1.1
194
195			/*
196			* Driver Open() routine
197			*/
198
199			int16 EtherOpen(uint32 pb, uint32 dce)
200			{
201			D(bug("EtherOpen\n"));
202
203			// Allocate driver data
204			M68kRegisters r;
205			r.d[0] = SIZEOF_etherdata;
206			Execute68kTrap(0xa71e, &r); // NewPtrSysClear()
207			if (r.a[0] == 0)
208			return openErr;
209			ether_data = r.a[0];
210	cebix	1.5	D(bug(" data %08x\n", ether_data));
211	cebix	1.1
212			WriteMacInt16(ether_data + ed_DeferredTask + qType, dtQType);
213			WriteMacInt32(ether_data + ed_DeferredTask + dtAddr, ether_data + ed_Code);
214			WriteMacInt32(ether_data + ed_DeferredTask + dtParam, ether_data + ed_Result);
215			// Deferred function for signalling that packet write is complete (pointer to mydtResult in a1)
216			WriteMacInt16(ether_data + ed_Code, 0x2019); // move.l (a1)+,d0 (result)
217			WriteMacInt16(ether_data + ed_Code + 2, 0x2251); // move.l (a1),a1 (dce)
218			WriteMacInt32(ether_data + ed_Code + 4, 0x207808fc); // move.l JIODone,a0
219			WriteMacInt16(ether_data + ed_Code + 8, 0x4ed0); // jmp (a0)
220
221			WriteMacInt32(ether_data + ed_DCE, dce);
222			// ReadPacket/ReadRest routines
223			WriteMacInt16(ether_data + ed_ReadPacket, 0x6010); // bra 2
224			WriteMacInt16(ether_data + ed_ReadPacket + 2, 0x3003); // move.w d3,d0
225			WriteMacInt16(ether_data + ed_ReadPacket + 4, 0x9041); // sub.w d1,d0
226			WriteMacInt16(ether_data + ed_ReadPacket + 6, 0x4a43); // tst.w d3
227			WriteMacInt16(ether_data + ed_ReadPacket + 8, 0x6702); // beq 1
228			WriteMacInt16(ether_data + ed_ReadPacket + 10, M68K_EMUL_OP_ETHER_READ_PACKET);
229			WriteMacInt16(ether_data + ed_ReadPacket + 12, 0x3600); //1 move.w d0,d3
230			WriteMacInt16(ether_data + ed_ReadPacket + 14, 0x7000); // moveq #0,d0
231			WriteMacInt16(ether_data + ed_ReadPacket + 16, 0x4e75); // rts
232			WriteMacInt16(ether_data + ed_ReadPacket + 18, M68K_EMUL_OP_ETHER_READ_PACKET); //2
233			WriteMacInt16(ether_data + ed_ReadPacket + 20, 0x4a43); // tst.w d3
234			WriteMacInt16(ether_data + ed_ReadPacket + 22, 0x4e75); // rts
235			return 0;
236			}
237
238
239			/*
240			* Driver Control() routine
241			*/
242
243			int16 EtherControl(uint32 pb, uint32 dce)
244			{
245			uint16 code = ReadMacInt16(pb + csCode);
246			D(bug("EtherControl %d\n", code));
247			switch (code) {
248	cebix	1.5	case 1: // KillIO
249	cebix	1.1	return -1;
250
251			case kENetAddMulti: // Add multicast address
252	cebix	1.5	D(bug(" AddMulti %08x%04x\n", ReadMacInt32(pb + eMultiAddr), ReadMacInt16(pb + eMultiAddr + 4)));
253			if (net_open && !udp_tunnel)
254	cebix	1.1	return ether_add_multicast(pb);
255	cebix	1.5	return noErr;
256	cebix	1.1
257			case kENetDelMulti: // Delete multicast address
258	cebix	1.5	D(bug(" DelMulti %08x%04x\n", ReadMacInt32(pb + eMultiAddr), ReadMacInt16(pb + eMultiAddr + 4)));
259			if (net_open && !udp_tunnel)
260	cebix	1.1	return ether_del_multicast(pb);
261	cebix	1.5	return noErr;
262
263			case kENetAttachPH: { // Attach protocol handler
264			uint16 type = ReadMacInt16(pb + eProtType);
265			uint32 handler = ReadMacInt32(pb + ePointer);
266			D(bug(" AttachPH prot %04x, handler %08x\n", type, handler));
267			if (net_open) {
268			if (udp_tunnel) {
269			if (udp_protocols.find(type) != udp_protocols.end())
270			return lapProtErr;
271			udp_protocols[type] = handler;
272			} else
273			return ether_attach_ph(type, handler);
274			}
275			return noErr;
276			}
277
278			case kENetDetachPH: { // Detach protocol handler
279			uint16 type = ReadMacInt16(pb + eProtType);
280			D(bug(" DetachPH prot %04x\n", type));
281			if (net_open) {
282			if (udp_tunnel) {
283			if (udp_protocols.erase(type) == 0)
284			return lapProtErr;
285			} else
286			return ether_detach_ph(type);
287			}
288			return noErr;
289			}
290	cebix	1.1
291	cebix	1.5	case kENetWrite: { // Transmit raw Ethernet packet
292			uint32 wds = ReadMacInt32(pb + ePointer);
293			D(bug(" EtherWrite\n"));
294			if (ReadMacInt16(wds) < 14)
295	cebix	1.1	return eLenErr; // Header incomplete
296	cebix	1.5	if (net_open) {
297			#if SUPPORTS_UDP_TUNNEL
298			if (udp_tunnel) {
299
300			// Copy packet to buffer
301			uint8 packet[1514];
302			int len = ether_wds_to_buffer(wds, packet);
303
304			// Set source address and extract destination address
305			memcpy(packet + 6, ether_addr, 6);
306			uint32 dest_ip;
307			if (packet[0] == 'B' && packet[1] == '2')
308			dest_ip = (packet[2] << 24) \| (packet[3] << 16) \| (packet[4] << 8) \| packet[5];
309			else if (is_apple_talk_broadcast(packet))
310			dest_ip = INADDR_BROADCAST;
311			else
312			return eMultiErr;
313
314			#if MONITOR
315			bug("Sending Ethernet packet:\n");
316			for (int i=0; i<len; i++) {
317			bug("%02x ", packet[i]);
318			}
319			bug("\n");
320			#endif
321
322			// Send packet
323			struct sockaddr_in sa;
324			sa.sin_family = AF_INET;
325			sa.sin_addr.s_addr = htonl(dest_ip);
326			sa.sin_port = htons(udp_port);
327			if (sendto(udp_socket, packet, len, 0, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
328			D(bug("WARNING: Couldn't transmit packet\n"));
329			return excessCollsns;
330			}
331			} else
332			#endif
333			return ether_write(wds);
334			}
335			return noErr;
336			}
337	cebix	1.1
338			case kENetGetInfo: { // Get device information/statistics
339	cebix	1.5	D(bug(" GetInfo buf %08x, size %d\n", ReadMacInt32(pb + ePointer), ReadMacInt16(pb + eBuffSize)));
340	cebix	1.1
341			// Collect info (only ethernet address)
342			uint8 buf[18];
343			memset(buf, 0, 18);
344			memcpy(buf, ether_addr, 6);
345
346			// Transfer info to supplied buffer
347			int16 size = ReadMacInt16(pb + eBuffSize);
348			if (size > 18)
349			size = 18;
350			WriteMacInt16(pb + eDataSize, size); // Number of bytes actually written
351	cebix	1.2	Host2Mac_memcpy(ReadMacInt32(pb + ePointer), buf, size);
352	cebix	1.1	return noErr;
353			}
354
355			case kENetSetGeneral: // Set general mode (always in general mode)
356	cebix	1.5	D(bug(" SetGeneral\n"));
357	cebix	1.1	return noErr;
358
359			default:
360			printf("WARNING: Unknown EtherControl(%d)\n", code);
361			return controlErr;
362			}
363			}
364
365
366			/*
367			* Ethernet ReadPacket routine
368			*/
369
370			void EtherReadPacket(uint8 **src, uint32 &dest, uint32 &len, uint32 &remaining)
371			{
372	cebix	1.5	D(bug("EtherReadPacket src %p, dest %08x, len %08x, remaining %08x\n", *src, dest, len, remaining));
373	cebix	1.1	uint32 todo = len > remaining ? remaining : len;
374	cebix	1.2	Host2Mac_memcpy(dest, *src, todo);
375	cebix	1.1	*src += todo;
376			dest += todo;
377			len -= todo;
378			remaining -= todo;
379			}
380	cebix	1.5
381
382			#if SUPPORTS_UDP_TUNNEL
383			/*
384			* Read packet from UDP socket
385			*/
386
387			void ether_udp_read(uint8 packet, int length, struct sockaddr_in from)
388			{
389			// Drop packets sent by us
390			if (memcmp(packet + 6, ether_addr, 6) == 0)
391			return;
392
393			#if MONITOR
394			bug("Receiving Ethernet packet:\n");
395			for (int i=0; i<length; i++) {
396			bug("%02x ", packet[i]);
397			}
398			bug("\n");
399			#endif
400
401			// Get packet type
402			uint16 type = (packet[12] << 8) \| packet[13];
403
404			// Look for protocol
405			uint16 search_type = (type <= 1500 ? 0 : type);
406			if (udp_protocols.find(search_type) == udp_protocols.end())
407			return;
408			uint32 handler = udp_protocols[search_type];
409			if (handler == 0)
410			return;
411
412			// Copy header to RHA
413			Host2Mac_memcpy(ether_data + ed_RHA, packet, 14);
414			D(bug(" header %08x%04x %08x%04x %04x\n", ReadMacInt32(ether_data + ed_RHA), ReadMacInt16(ether_data + ed_RHA + 4), ReadMacInt32(ether_data + ed_RHA + 6), ReadMacInt16(ether_data + ed_RHA + 10), ReadMacInt16(ether_data + ed_RHA + 12)));
415
416			// Call protocol handler
417			M68kRegisters r;
418			r.d[0] = type; // Packet type
419			r.d[1] = length - 14; // Remaining packet length (without header, for ReadPacket)
420			r.a[0] = (uint32)packet + 14; // Pointer to packet (host address, for ReadPacket)
421			r.a[3] = ether_data + ed_RHA + 14; // Pointer behind header in RHA
422			r.a[4] = ether_data + ed_ReadPacket; // Pointer to ReadPacket/ReadRest routines
423			D(bug(" calling protocol handler %08x, type %08x, length %08x, data %08x, rha %08x, read_packet %08x\n", handler, r.d[0], r.d[1], r.a[0], r.a[3], r.a[4]));
424			Execute68k(handler, &r);
425			}
426			#endif