BasiliskII/src/ether.cpp

/*
 *  ether.cpp - Ethernet device driver
 *
 *  Basilisk II (C) 1997-2008 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 <unistd.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


#ifdef __BEOS__
#define CLOSESOCKET closesocket
#else
#define CLOSESOCKET close
#endif


// 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");
                        CLOSESOCKET(udp_socket);
                        udp_socket = -1;
                        return;
                }

                // Retrieve local IP address (or at least one of them)
                socklen_t sa_length = sizeof(sa);
                getsockname(udp_socket, (struct sockaddr *)&sa, &sa_length);
                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;
#ifdef __BEOS__
                setsockopt(udp_socket, SOL_SOCKET, SO_NONBLOCK, &on, sizeof(on));
#else
                setsockopt(udp_socket, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on));
                ioctl(udp_socket, FIONBIO, &on);
#endif

                // Start thread for packet reception
                if (!ether_start_udp_thread(udp_socket)) {
                        CLOSESOCKET(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();
                                CLOSESOCKET(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 or Ethernet 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;
}

static inline bool is_ethernet_broadcast(uint8 *p)
{
        return p[0] == 0xff && p[1] == 0xff && p[2] == 0xff
            && 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 "));
                        if (ReadMacInt16(wds) < 14)
                                return eLenErr; // Header incomplete

                        // Set source address
                        uint32 hdr = ReadMacInt32(wds + 2);
                        Host2Mac_memcpy(hdr + 6, ether_addr, 6);
                        D(bug("to %08x%04x, type %04x\n", ReadMacInt32(hdr), ReadMacInt16(hdr + 4), ReadMacInt16(hdr + 12)));

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

                                        // Extract destination address
                                        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) || is_ethernet_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(uint32 &src, uint32 &dest, uint32 &len, uint32 &remaining)
{
        D(bug("EtherReadPacket src %08x, dest %08x, len %08x, remaining %08x\n", src, dest, len, remaining));
        uint32 todo = len > remaining ? remaining : len;
        Mac2Mac_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(uint32 packet, int length, struct sockaddr_in *from)
{
        // Drop packets sent by us
        if (memcmp(Mac2HostAddr(packet) + 6, ether_addr, 6) == 0)
                return;

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

        // Get packet type
        uint16 type = ReadMacInt16(packet + 12);

        // 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
        Mac2Mac_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] = packet + 14;                                                   // Pointer to packet (Mac 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


/*
 *  Ethernet packet allocator
 */

#if SIZEOF_VOID_P != 4 || REAL_ADDRESSING == 0
static uint32 ether_packet = 0;                 // Ethernet packet (cached allocation)
static uint32 n_ether_packets = 0;              // Number of ethernet packets allocated so far (should be at most 1)

EthernetPacket::EthernetPacket()
{
        ++n_ether_packets;
        if (ether_packet && n_ether_packets == 1)
                packet = ether_packet;
        else {
        M68kRegisters r;
        r.d[0] = 1516;
        Execute68kTrap(0xa71e, &r);             // NewPtrSysClear()
                assert(r.a[0] != 0);
                packet = r.a[0];
                if (ether_packet == 0)
                        ether_packet = packet;
        }
}

EthernetPacket::~EthernetPacket()
{
        --n_ether_packets;
        if (packet != ether_packet) {
                M68kRegisters r;
                r.a[0] = packet;
                Execute68kTrap(0xa01f, &r);             // DisposePtr
        }
        if (n_ether_packets > 0) {
                bug("WARNING: Nested allocation of ethernet packets!\n");
        }
}
#endif
Revision:	1.16
Committed:	2008-01-01T09:40:31Z (16 years, 11 months ago) by gbeauche
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.15:	+1 -1 lines
Log Message:	Happy New Year!
#	User	Rev	Content
1	cebix	1.1	/*
2			* ether.cpp - Ethernet device driver
3			*
4	gbeauche	1.16	* Basilisk II (C) 1997-2008 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	cebix	1.11	#include <unistd.h>
39	cebix	1.5	#include <errno.h>
40			#endif
41
42	cebix	1.6	#include "cpu_emulation.h"
43			#include "main.h"
44			#include "macos_util.h"
45			#include "emul_op.h"
46			#include "prefs.h"
47			#include "ether.h"
48			#include "ether_defs.h"
49	cebix	1.5
50			#ifndef NO_STD_NAMESPACE
51			using std::map;
52			#endif
53
54	cebix	1.1	#define DEBUG 0
55			#include "debug.h"
56
57	cebix	1.5	#define MONITOR 0
58
59	cebix	1.1
60	cebix	1.8	#ifdef __BEOS__
61			#define CLOSESOCKET closesocket
62			#else
63			#define CLOSESOCKET close
64			#endif
65
66
67	cebix	1.1	// Global variables
68	cebix	1.5	uint8 ether_addr[6]; // Ethernet address (set by ether_init())
69			static bool net_open = false; // Flag: initialization succeeded, network device open (set by EtherInit())
70
71			static bool udp_tunnel = false; // Flag: tunnelling AppleTalk over UDP using BSD socket API
72			static uint16 udp_port;
73			static int udp_socket = -1;
74
75			// Mac address of driver data in MacOS RAM
76			uint32 ether_data = 0;
77	cebix	1.1
78	cebix	1.5	// Attached network protocols for UDP tunneling, maps protocol type to MacOS handler address
79			static map<uint16, uint32> udp_protocols;
80
81
82			/*
83			* Initialization
84			*/
85
86			void EtherInit(void)
87			{
88			net_open = false;
89			udp_tunnel = false;
90
91			#if SUPPORTS_UDP_TUNNEL
92			// UDP tunnelling requested?
93			if (PrefsFindBool("udptunnel")) {
94			udp_tunnel = true;
95			udp_port = PrefsFindInt32("udpport");
96
97			// Open UDP socket
98			udp_socket = socket(PF_INET, SOCK_DGRAM, 0);
99			if (udp_socket < 0) {
100			perror("socket");
101			return;
102			}
103
104			// Bind to specified address and port
105			struct sockaddr_in sa;
106			memset(&sa, 0, sizeof(sa));
107			sa.sin_family = AF_INET;
108			sa.sin_addr.s_addr = INADDR_ANY;
109			sa.sin_port = htons(udp_port);
110			if (bind(udp_socket, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
111			perror("bind");
112	cebix	1.8	CLOSESOCKET(udp_socket);
113	cebix	1.5	udp_socket = -1;
114			return;
115			}
116
117			// Retrieve local IP address (or at least one of them)
118	cebix	1.10	socklen_t sa_length = sizeof(sa);
119			getsockname(udp_socket, (struct sockaddr *)&sa, &sa_length);
120	cebix	1.5	uint32 udp_ip = sa.sin_addr.s_addr;
121			if (udp_ip == INADDR_ANY \|\| udp_ip == INADDR_LOOPBACK) {
122			char name[256];
123			gethostname(name, sizeof(name));
124			struct hostent *local = gethostbyname(name);
125			if (local)
126			udp_ip = (uint32 )local->h_addr_list[0];
127			}
128			udp_ip = ntohl(udp_ip);
129
130			// Construct dummy Ethernet address from local IP address
131			ether_addr[0] = 'B';
132			ether_addr[1] = '2';
133			ether_addr[2] = udp_ip >> 24;
134			ether_addr[3] = udp_ip >> 16;
135			ether_addr[4] = udp_ip >> 8;
136			ether_addr[5] = udp_ip;
137			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]));
138
139			// Set socket options
140			int on = 1;
141	cebix	1.8	#ifdef __BEOS__
142			setsockopt(udp_socket, SOL_SOCKET, SO_NONBLOCK, &on, sizeof(on));
143			#else
144	cebix	1.5	setsockopt(udp_socket, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on));
145			ioctl(udp_socket, FIONBIO, &on);
146	cebix	1.8	#endif
147	cebix	1.5
148			// Start thread for packet reception
149			if (!ether_start_udp_thread(udp_socket)) {
150	cebix	1.8	CLOSESOCKET(udp_socket);
151	cebix	1.5	udp_socket = -1;
152			return;
153			}
154
155			net_open = true;
156			} else
157			#endif
158			if (ether_init())
159			net_open = true;
160			}
161
162
163			/*
164			* Deinitialization
165			*/
166
167			void EtherExit(void)
168			{
169			if (net_open) {
170			#if SUPPORTS_UDP_TUNNEL
171			if (udp_tunnel) {
172			if (udp_socket >= 0) {
173			ether_stop_udp_thread();
174	cebix	1.8	CLOSESOCKET(udp_socket);
175	cebix	1.5	udp_socket = -1;
176			}
177			} else
178			#endif
179			ether_exit();
180			net_open = false;
181			}
182	cebix	1.6	}
183
184
185			/*
186			* Reset
187			*/
188
189			void EtherReset(void)
190			{
191			udp_protocols.clear();
192			ether_reset();
193	cebix	1.5	}
194
195
196			/*
197	cebix	1.7	* Check whether Ethernet address is AppleTalk or Ethernet broadcast address
198	cebix	1.5	*/
199
200			static inline bool is_apple_talk_broadcast(uint8 *p)
201			{
202			return p[0] == 0x09 && p[1] == 0x00 && p[2] == 0x07
203			&& p[3] == 0xff && p[4] == 0xff && p[5] == 0xff;
204			}
205	cebix	1.1
206	cebix	1.7	static inline bool is_ethernet_broadcast(uint8 *p)
207			{
208			return p[0] == 0xff && p[1] == 0xff && p[2] == 0xff
209			&& p[3] == 0xff && p[4] == 0xff && p[5] == 0xff;
210			}
211
212	cebix	1.1
213			/*
214			* Driver Open() routine
215			*/
216
217			int16 EtherOpen(uint32 pb, uint32 dce)
218			{
219			D(bug("EtherOpen\n"));
220
221			// Allocate driver data
222			M68kRegisters r;
223			r.d[0] = SIZEOF_etherdata;
224			Execute68kTrap(0xa71e, &r); // NewPtrSysClear()
225			if (r.a[0] == 0)
226			return openErr;
227			ether_data = r.a[0];
228	cebix	1.5	D(bug(" data %08x\n", ether_data));
229	cebix	1.1
230			WriteMacInt16(ether_data + ed_DeferredTask + qType, dtQType);
231			WriteMacInt32(ether_data + ed_DeferredTask + dtAddr, ether_data + ed_Code);
232			WriteMacInt32(ether_data + ed_DeferredTask + dtParam, ether_data + ed_Result);
233			// Deferred function for signalling that packet write is complete (pointer to mydtResult in a1)
234			WriteMacInt16(ether_data + ed_Code, 0x2019); // move.l (a1)+,d0 (result)
235			WriteMacInt16(ether_data + ed_Code + 2, 0x2251); // move.l (a1),a1 (dce)
236			WriteMacInt32(ether_data + ed_Code + 4, 0x207808fc); // move.l JIODone,a0
237			WriteMacInt16(ether_data + ed_Code + 8, 0x4ed0); // jmp (a0)
238
239			WriteMacInt32(ether_data + ed_DCE, dce);
240			// ReadPacket/ReadRest routines
241			WriteMacInt16(ether_data + ed_ReadPacket, 0x6010); // bra 2
242			WriteMacInt16(ether_data + ed_ReadPacket + 2, 0x3003); // move.w d3,d0
243			WriteMacInt16(ether_data + ed_ReadPacket + 4, 0x9041); // sub.w d1,d0
244			WriteMacInt16(ether_data + ed_ReadPacket + 6, 0x4a43); // tst.w d3
245			WriteMacInt16(ether_data + ed_ReadPacket + 8, 0x6702); // beq 1
246			WriteMacInt16(ether_data + ed_ReadPacket + 10, M68K_EMUL_OP_ETHER_READ_PACKET);
247			WriteMacInt16(ether_data + ed_ReadPacket + 12, 0x3600); //1 move.w d0,d3
248			WriteMacInt16(ether_data + ed_ReadPacket + 14, 0x7000); // moveq #0,d0
249			WriteMacInt16(ether_data + ed_ReadPacket + 16, 0x4e75); // rts
250			WriteMacInt16(ether_data + ed_ReadPacket + 18, M68K_EMUL_OP_ETHER_READ_PACKET); //2
251			WriteMacInt16(ether_data + ed_ReadPacket + 20, 0x4a43); // tst.w d3
252			WriteMacInt16(ether_data + ed_ReadPacket + 22, 0x4e75); // rts
253			return 0;
254			}
255
256
257			/*
258			* Driver Control() routine
259			*/
260
261			int16 EtherControl(uint32 pb, uint32 dce)
262			{
263			uint16 code = ReadMacInt16(pb + csCode);
264			D(bug("EtherControl %d\n", code));
265			switch (code) {
266	cebix	1.5	case 1: // KillIO
267	cebix	1.1	return -1;
268
269			case kENetAddMulti: // Add multicast address
270	cebix	1.5	D(bug(" AddMulti %08x%04x\n", ReadMacInt32(pb + eMultiAddr), ReadMacInt16(pb + eMultiAddr + 4)));
271			if (net_open && !udp_tunnel)
272	cebix	1.1	return ether_add_multicast(pb);
273	cebix	1.5	return noErr;
274	cebix	1.1
275			case kENetDelMulti: // Delete multicast address
276	cebix	1.5	D(bug(" DelMulti %08x%04x\n", ReadMacInt32(pb + eMultiAddr), ReadMacInt16(pb + eMultiAddr + 4)));
277			if (net_open && !udp_tunnel)
278	cebix	1.1	return ether_del_multicast(pb);
279	cebix	1.5	return noErr;
280
281			case kENetAttachPH: { // Attach protocol handler
282			uint16 type = ReadMacInt16(pb + eProtType);
283			uint32 handler = ReadMacInt32(pb + ePointer);
284			D(bug(" AttachPH prot %04x, handler %08x\n", type, handler));
285			if (net_open) {
286			if (udp_tunnel) {
287			if (udp_protocols.find(type) != udp_protocols.end())
288			return lapProtErr;
289			udp_protocols[type] = handler;
290			} else
291			return ether_attach_ph(type, handler);
292			}
293			return noErr;
294			}
295
296			case kENetDetachPH: { // Detach protocol handler
297			uint16 type = ReadMacInt16(pb + eProtType);
298			D(bug(" DetachPH prot %04x\n", type));
299			if (net_open) {
300			if (udp_tunnel) {
301			if (udp_protocols.erase(type) == 0)
302			return lapProtErr;
303			} else
304			return ether_detach_ph(type);
305			}
306			return noErr;
307			}
308	cebix	1.1
309	cebix	1.5	case kENetWrite: { // Transmit raw Ethernet packet
310			uint32 wds = ReadMacInt32(pb + ePointer);
311	cebix	1.7	D(bug(" EtherWrite "));
312	cebix	1.5	if (ReadMacInt16(wds) < 14)
313	cebix	1.1	return eLenErr; // Header incomplete
314	cebix	1.7
315			// Set source address
316			uint32 hdr = ReadMacInt32(wds + 2);
317			Host2Mac_memcpy(hdr + 6, ether_addr, 6);
318			D(bug("to %08x%04x, type %04x\n", ReadMacInt32(hdr), ReadMacInt16(hdr + 4), ReadMacInt16(hdr + 12)));
319
320	cebix	1.5	if (net_open) {
321			#if SUPPORTS_UDP_TUNNEL
322			if (udp_tunnel) {
323
324			// Copy packet to buffer
325			uint8 packet[1514];
326			int len = ether_wds_to_buffer(wds, packet);
327
328	cebix	1.7	// Extract destination address
329	cebix	1.5	uint32 dest_ip;
330			if (packet[0] == 'B' && packet[1] == '2')
331			dest_ip = (packet[2] << 24) \| (packet[3] << 16) \| (packet[4] << 8) \| packet[5];
332	cebix	1.7	else if (is_apple_talk_broadcast(packet) \|\| is_ethernet_broadcast(packet))
333	cebix	1.5	dest_ip = INADDR_BROADCAST;
334			else
335			return eMultiErr;
336
337			#if MONITOR
338			bug("Sending Ethernet packet:\n");
339			for (int i=0; i<len; i++) {
340			bug("%02x ", packet[i]);
341			}
342			bug("\n");
343			#endif
344
345			// Send packet
346			struct sockaddr_in sa;
347			sa.sin_family = AF_INET;
348			sa.sin_addr.s_addr = htonl(dest_ip);
349			sa.sin_port = htons(udp_port);
350			if (sendto(udp_socket, packet, len, 0, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
351			D(bug("WARNING: Couldn't transmit packet\n"));
352			return excessCollsns;
353			}
354			} else
355			#endif
356			return ether_write(wds);
357			}
358			return noErr;
359			}
360	cebix	1.1
361			case kENetGetInfo: { // Get device information/statistics
362	cebix	1.5	D(bug(" GetInfo buf %08x, size %d\n", ReadMacInt32(pb + ePointer), ReadMacInt16(pb + eBuffSize)));
363	cebix	1.1
364			// Collect info (only ethernet address)
365			uint8 buf[18];
366			memset(buf, 0, 18);
367			memcpy(buf, ether_addr, 6);
368
369			// Transfer info to supplied buffer
370			int16 size = ReadMacInt16(pb + eBuffSize);
371			if (size > 18)
372			size = 18;
373			WriteMacInt16(pb + eDataSize, size); // Number of bytes actually written
374	cebix	1.2	Host2Mac_memcpy(ReadMacInt32(pb + ePointer), buf, size);
375	cebix	1.1	return noErr;
376			}
377
378			case kENetSetGeneral: // Set general mode (always in general mode)
379	cebix	1.5	D(bug(" SetGeneral\n"));
380	cebix	1.1	return noErr;
381
382			default:
383			printf("WARNING: Unknown EtherControl(%d)\n", code);
384			return controlErr;
385			}
386			}
387
388
389			/*
390			* Ethernet ReadPacket routine
391			*/
392
393	gbeauche	1.14	void EtherReadPacket(uint32 &src, uint32 &dest, uint32 &len, uint32 &remaining)
394	cebix	1.1	{
395	gbeauche	1.14	D(bug("EtherReadPacket src %08x, dest %08x, len %08x, remaining %08x\n", src, dest, len, remaining));
396	cebix	1.1	uint32 todo = len > remaining ? remaining : len;
397	gbeauche	1.14	Mac2Mac_memcpy(dest, src, todo);
398			src += todo;
399	cebix	1.1	dest += todo;
400			len -= todo;
401			remaining -= todo;
402			}
403	cebix	1.5
404
405			#if SUPPORTS_UDP_TUNNEL
406			/*
407			* Read packet from UDP socket
408			*/
409
410	gbeauche	1.14	void ether_udp_read(uint32 packet, int length, struct sockaddr_in *from)
411	cebix	1.5	{
412			// Drop packets sent by us
413	gbeauche	1.14	if (memcmp(Mac2HostAddr(packet) + 6, ether_addr, 6) == 0)
414	cebix	1.5	return;
415
416			#if MONITOR
417			bug("Receiving Ethernet packet:\n");
418			for (int i=0; i<length; i++) {
419	gbeauche	1.14	bug("%02x ", ReadMacInt8(packet + i));
420	cebix	1.5	}
421			bug("\n");
422			#endif
423
424			// Get packet type
425	gbeauche	1.14	uint16 type = ReadMacInt16(packet + 12);
426	cebix	1.5
427			// Look for protocol
428			uint16 search_type = (type <= 1500 ? 0 : type);
429			if (udp_protocols.find(search_type) == udp_protocols.end())
430			return;
431			uint32 handler = udp_protocols[search_type];
432			if (handler == 0)
433			return;
434
435			// Copy header to RHA
436	gbeauche	1.14	Mac2Mac_memcpy(ether_data + ed_RHA, packet, 14);
437	cebix	1.5	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)));
438
439			// Call protocol handler
440			M68kRegisters r;
441			r.d[0] = type; // Packet type
442			r.d[1] = length - 14; // Remaining packet length (without header, for ReadPacket)
443	gbeauche	1.14	r.a[0] = packet + 14; // Pointer to packet (Mac address, for ReadPacket)
444	cebix	1.5	r.a[3] = ether_data + ed_RHA + 14; // Pointer behind header in RHA
445			r.a[4] = ether_data + ed_ReadPacket; // Pointer to ReadPacket/ReadRest routines
446			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]));
447			Execute68k(handler, &r);
448			}
449			#endif
450	gbeauche	1.14
451
452			/*
453			* Ethernet packet allocator
454			*/
455
456	gbeauche	1.15	#if SIZEOF_VOID_P != 4 \|\| REAL_ADDRESSING == 0
457	gbeauche	1.14	static uint32 ether_packet = 0; // Ethernet packet (cached allocation)
458			static uint32 n_ether_packets = 0; // Number of ethernet packets allocated so far (should be at most 1)
459
460			EthernetPacket::EthernetPacket()
461			{
462			++n_ether_packets;
463			if (ether_packet && n_ether_packets == 1)
464			packet = ether_packet;
465			else {
466			M68kRegisters r;
467			r.d[0] = 1516;
468			Execute68kTrap(0xa71e, &r); // NewPtrSysClear()
469			assert(r.a[0] != 0);
470			packet = r.a[0];
471			if (ether_packet == 0)
472			ether_packet = packet;
473			}
474			}
475
476			EthernetPacket::~EthernetPacket()
477			{
478			--n_ether_packets;
479			if (packet != ether_packet) {
480			M68kRegisters r;
481			r.a[0] = packet;
482			Execute68kTrap(0xa01f, &r); // DisposePtr
483			}
484			if (n_ether_packets > 0) {
485			bug("WARNING: Nested allocation of ethernet packets!\n");
486			}
487			}
488			#endif