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, 4 months 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
#	Content
1	/*
2	* ether.cpp - Ethernet device driver
3	*
4	* Basilisk II (C) 1997-2001 Christian Bauer
5	*
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	#include "sysdeps.h"
29
30	#include <string.h>
31	#include <map>
32
33	#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	#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
49	#ifndef NO_STD_NAMESPACE
50	using std::map;
51	#endif
52
53	#define DEBUG 0
54	#include "debug.h"
55
56	#define MONITOR 0
57
58
59	// Global variables
60	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
70	// 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	}
171
172
173	/*
174	* Reset
175	*/
176
177	void EtherReset(void)
178	{
179	udp_protocols.clear();
180	ether_reset();
181	}
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
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	D(bug(" data %08x\n", ether_data));
211
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	case 1: // KillIO
249	return -1;
250
251	case kENetAddMulti: // Add multicast address
252	D(bug(" AddMulti %08x%04x\n", ReadMacInt32(pb + eMultiAddr), ReadMacInt16(pb + eMultiAddr + 4)));
253	if (net_open && !udp_tunnel)
254	return ether_add_multicast(pb);
255	return noErr;
256
257	case kENetDelMulti: // Delete multicast address
258	D(bug(" DelMulti %08x%04x\n", ReadMacInt32(pb + eMultiAddr), ReadMacInt16(pb + eMultiAddr + 4)));
259	if (net_open && !udp_tunnel)
260	return ether_del_multicast(pb);
261	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
291	case kENetWrite: { // Transmit raw Ethernet packet
292	uint32 wds = ReadMacInt32(pb + ePointer);
293	D(bug(" EtherWrite\n"));
294	if (ReadMacInt16(wds) < 14)
295	return eLenErr; // Header incomplete
296	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
338	case kENetGetInfo: { // Get device information/statistics
339	D(bug(" GetInfo buf %08x, size %d\n", ReadMacInt32(pb + ePointer), ReadMacInt16(pb + eBuffSize)));
340
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	Host2Mac_memcpy(ReadMacInt32(pb + ePointer), buf, size);
352	return noErr;
353	}
354
355	case kENetSetGeneral: // Set general mode (always in general mode)
356	D(bug(" SetGeneral\n"));
357	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	D(bug("EtherReadPacket src %p, dest %08x, len %08x, remaining %08x\n", *src, dest, len, remaining));
373	uint32 todo = len > remaining ? remaining : len;
374	Host2Mac_memcpy(dest, *src, todo);
375	*src += todo;
376	dest += todo;
377	len -= todo;
378	remaining -= todo;
379	}
380
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