1999-10-03 14:16:26 +00:00
|
|
|
/*
|
2001-03-29 14:20:55 +00:00
|
|
|
* ether_unix.cpp - Ethernet device driver, Unix specific stuff (Linux and FreeBSD)
|
1999-10-03 14:16:26 +00:00
|
|
|
*
|
2005-01-30 21:42:16 +00:00
|
|
|
* Basilisk II (C) 1997-2005 Christian Bauer
|
1999-10-03 14:16:26 +00:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "sysdeps.h"
|
|
|
|
|
2005-05-13 17:43:38 +00:00
|
|
|
#ifdef HAVE_SYS_POLL_H
|
1999-10-03 14:16:26 +00:00
|
|
|
#include <sys/poll.h>
|
2005-05-13 17:43:38 +00:00
|
|
|
#endif
|
|
|
|
#include <sys/ioctl.h>
|
2001-07-13 15:39:25 +00:00
|
|
|
#include <sys/socket.h>
|
2004-05-09 16:16:05 +00:00
|
|
|
#include <sys/wait.h>
|
2001-07-13 15:39:25 +00:00
|
|
|
#include <netinet/in.h>
|
2000-07-13 16:12:33 +00:00
|
|
|
#include <pthread.h>
|
1999-10-03 14:16:26 +00:00
|
|
|
#include <semaphore.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <stdio.h>
|
2001-07-13 15:39:25 +00:00
|
|
|
#include <map>
|
2001-07-12 19:48:28 +00:00
|
|
|
|
2005-05-13 17:43:38 +00:00
|
|
|
#if defined(__FreeBSD__) || defined(sgi) || (defined(__APPLE__) && defined(__MACH__))
|
2001-03-29 14:20:55 +00:00
|
|
|
#include <net/if.h>
|
|
|
|
#endif
|
|
|
|
|
2004-05-09 16:16:05 +00:00
|
|
|
#if defined(HAVE_LINUX_IF_H) && defined(HAVE_LINUX_IF_TUN_H)
|
|
|
|
#include <linux/if.h>
|
|
|
|
#include <linux/if_tun.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(HAVE_NET_IF_H) && defined(HAVE_NET_IF_TUN_H)
|
|
|
|
#include <net/if.h>
|
|
|
|
#include <net/if_tun.h>
|
|
|
|
#endif
|
|
|
|
|
2005-05-13 14:02:37 +00:00
|
|
|
// XXX: slirp works on 64-bit platforms, sometimes
|
2005-05-13 09:21:21 +00:00
|
|
|
#define HAVE_SLIRP 1
|
2005-05-13 14:02:37 +00:00
|
|
|
#include "libslirp.h"
|
2005-05-13 09:21:21 +00:00
|
|
|
|
1999-10-03 14:16:26 +00:00
|
|
|
#include "cpu_emulation.h"
|
|
|
|
#include "main.h"
|
|
|
|
#include "macos_util.h"
|
|
|
|
#include "prefs.h"
|
|
|
|
#include "user_strings.h"
|
|
|
|
#include "ether.h"
|
|
|
|
#include "ether_defs.h"
|
|
|
|
|
2001-07-13 15:39:25 +00:00
|
|
|
#ifndef NO_STD_NAMESPACE
|
|
|
|
using std::map;
|
|
|
|
#endif
|
|
|
|
|
1999-10-03 14:16:26 +00:00
|
|
|
#define DEBUG 0
|
|
|
|
#include "debug.h"
|
|
|
|
|
|
|
|
#define MONITOR 0
|
|
|
|
|
|
|
|
|
2004-05-09 16:16:05 +00:00
|
|
|
// Ethernet device types
|
|
|
|
enum {
|
|
|
|
NET_IF_SHEEPNET,
|
|
|
|
NET_IF_ETHERTAP,
|
|
|
|
NET_IF_TUNTAP,
|
2005-05-13 09:21:21 +00:00
|
|
|
NET_IF_SLIRP
|
2004-05-09 16:16:05 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
// Constants
|
|
|
|
static const char ETHERCONFIG_FILE_NAME[] = DATADIR "/tunconfig";
|
|
|
|
|
1999-10-03 14:16:26 +00:00
|
|
|
// Global variables
|
|
|
|
static int fd = -1; // fd of sheep_net device
|
|
|
|
static pthread_t ether_thread; // Packet reception thread
|
|
|
|
static pthread_attr_t ether_thread_attr; // Packet reception thread attributes
|
|
|
|
static bool thread_active = false; // Flag: Packet reception thread installed
|
|
|
|
static sem_t int_ack; // Interrupt acknowledge semaphore
|
2001-07-12 19:48:28 +00:00
|
|
|
static bool udp_tunnel; // Flag: UDP tunnelling active, fd is the socket descriptor
|
2004-05-09 16:16:05 +00:00
|
|
|
static int net_if_type = -1; // Ethernet device type
|
2004-05-09 16:32:12 +00:00
|
|
|
static char *net_if_name = NULL; // TUN/TAP device name
|
2004-05-09 16:16:05 +00:00
|
|
|
static const char *net_if_script = NULL; // Network config script
|
2005-05-13 09:21:21 +00:00
|
|
|
static pthread_t slirp_thread; // Slirp reception thread
|
|
|
|
static bool slirp_thread_active = false; // Flag: Slirp reception threadinstalled
|
|
|
|
static int slirp_output_fd = -1; // fd of slirp output pipe
|
1999-10-03 14:16:26 +00:00
|
|
|
|
2001-07-13 15:39:25 +00:00
|
|
|
// Attached network protocols, maps protocol type to MacOS handler address
|
|
|
|
static map<uint16, uint32> net_protocols;
|
|
|
|
|
1999-10-03 14:16:26 +00:00
|
|
|
// Prototypes
|
|
|
|
static void *receive_func(void *arg);
|
2005-05-13 09:21:21 +00:00
|
|
|
static void *slirp_receive_func(void *arg);
|
2005-05-13 17:43:38 +00:00
|
|
|
static int poll_fd(int fd);
|
1999-10-03 14:16:26 +00:00
|
|
|
|
|
|
|
|
2001-07-12 19:48:28 +00:00
|
|
|
/*
|
|
|
|
* Start packet reception thread
|
|
|
|
*/
|
|
|
|
|
|
|
|
static bool start_thread(void)
|
|
|
|
{
|
|
|
|
if (sem_init(&int_ack, 0, 0) < 0) {
|
|
|
|
printf("WARNING: Cannot init semaphore");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2002-02-07 16:10:57 +00:00
|
|
|
Set_pthread_attr(ðer_thread_attr, 1);
|
2001-07-12 19:48:28 +00:00
|
|
|
thread_active = (pthread_create(ðer_thread, ðer_thread_attr, receive_func, NULL) == 0);
|
|
|
|
if (!thread_active) {
|
|
|
|
printf("WARNING: Cannot start Ethernet thread");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2005-05-13 09:21:21 +00:00
|
|
|
#ifdef HAVE_SLIRP
|
|
|
|
if (net_if_type == NET_IF_SLIRP) {
|
|
|
|
slirp_thread_active = (pthread_create(&slirp_thread, NULL, slirp_receive_func, NULL) == 0);
|
|
|
|
if (!slirp_thread_active) {
|
|
|
|
printf("WARNING: Cannot start slirp reception thread\n");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2001-07-12 19:48:28 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Stop packet reception thread
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void stop_thread(void)
|
|
|
|
{
|
2005-05-13 09:21:21 +00:00
|
|
|
#ifdef HAVE_SLIRP
|
|
|
|
if (slirp_thread_active) {
|
|
|
|
pthread_cancel(slirp_thread);
|
|
|
|
pthread_join(slirp_thread, NULL);
|
|
|
|
slirp_thread_active = false;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2001-07-12 19:48:28 +00:00
|
|
|
if (thread_active) {
|
|
|
|
pthread_cancel(ether_thread);
|
|
|
|
pthread_join(ether_thread, NULL);
|
|
|
|
sem_destroy(&int_ack);
|
|
|
|
thread_active = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-05-09 16:16:05 +00:00
|
|
|
/*
|
|
|
|
* Execute network script up|down
|
|
|
|
*/
|
|
|
|
|
|
|
|
static bool execute_network_script(const char *action)
|
|
|
|
{
|
|
|
|
if (net_if_script == NULL || net_if_name == NULL)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
int pid = fork();
|
|
|
|
if (pid >= 0) {
|
|
|
|
if (pid == 0) {
|
|
|
|
char *args[4];
|
|
|
|
args[0] = (char *)net_if_script;
|
2004-05-09 16:32:12 +00:00
|
|
|
args[1] = net_if_name;
|
2004-05-09 16:16:05 +00:00
|
|
|
args[2] = (char *)action;
|
|
|
|
args[3] = NULL;
|
|
|
|
execv(net_if_script, args);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
int status;
|
|
|
|
while (waitpid(pid, &status, 0) != pid);
|
|
|
|
return WIFEXITED(status) && WEXITSTATUS(status) == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-10-03 14:16:26 +00:00
|
|
|
/*
|
|
|
|
* Initialization
|
|
|
|
*/
|
|
|
|
|
2001-07-12 19:48:28 +00:00
|
|
|
bool ether_init(void)
|
1999-10-03 14:16:26 +00:00
|
|
|
{
|
|
|
|
int nonblock = 1;
|
|
|
|
char str[256];
|
|
|
|
|
|
|
|
// Do nothing if no Ethernet device specified
|
|
|
|
const char *name = PrefsFindString("ether");
|
|
|
|
if (name == NULL)
|
2001-07-12 19:48:28 +00:00
|
|
|
return false;
|
1999-10-03 14:16:26 +00:00
|
|
|
|
2004-05-09 16:16:05 +00:00
|
|
|
// Determine Ethernet device type
|
|
|
|
net_if_type = -1;
|
|
|
|
if (strncmp(name, "tap", 3) == 0)
|
|
|
|
net_if_type = NET_IF_ETHERTAP;
|
|
|
|
#if ENABLE_TUNTAP
|
|
|
|
else if (strcmp(name, "tun") == 0)
|
|
|
|
net_if_type = NET_IF_TUNTAP;
|
2005-05-13 09:21:21 +00:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_SLIRP
|
|
|
|
else if (strcmp(name, "slirp") == 0)
|
|
|
|
net_if_type = NET_IF_SLIRP;
|
2004-05-09 16:16:05 +00:00
|
|
|
#endif
|
|
|
|
else
|
|
|
|
net_if_type = NET_IF_SHEEPNET;
|
1999-10-03 14:16:26 +00:00
|
|
|
|
2005-05-13 09:21:21 +00:00
|
|
|
#ifdef HAVE_SLIRP
|
|
|
|
// Initialize slirp library
|
|
|
|
if (net_if_type == NET_IF_SLIRP) {
|
|
|
|
slirp_init();
|
|
|
|
|
|
|
|
// Open slirp output pipe
|
|
|
|
int fds[2];
|
|
|
|
if (pipe(fds) < 0)
|
|
|
|
return false;
|
|
|
|
fd = fds[0];
|
|
|
|
slirp_output_fd = fds[1];
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2004-05-12 11:46:34 +00:00
|
|
|
// Open sheep_net or ethertap or TUN/TAP device
|
1999-10-03 14:16:26 +00:00
|
|
|
char dev_name[16];
|
2004-05-09 16:16:05 +00:00
|
|
|
switch (net_if_type) {
|
|
|
|
case NET_IF_ETHERTAP:
|
1999-10-03 14:16:26 +00:00
|
|
|
sprintf(dev_name, "/dev/%s", name);
|
2004-05-09 16:16:05 +00:00
|
|
|
break;
|
|
|
|
case NET_IF_TUNTAP:
|
2004-05-12 11:46:34 +00:00
|
|
|
strcpy(dev_name, "/dev/net/tun");
|
2004-05-09 16:16:05 +00:00
|
|
|
break;
|
|
|
|
case NET_IF_SHEEPNET:
|
1999-10-03 14:16:26 +00:00
|
|
|
strcpy(dev_name, "/dev/sheep_net");
|
2004-05-09 16:16:05 +00:00
|
|
|
break;
|
|
|
|
}
|
2005-05-13 09:21:21 +00:00
|
|
|
if (net_if_type != NET_IF_SLIRP) {
|
|
|
|
fd = open(dev_name, O_RDWR);
|
|
|
|
if (fd < 0) {
|
|
|
|
sprintf(str, GetString(STR_NO_SHEEP_NET_DRIVER_WARN), dev_name, strerror(errno));
|
|
|
|
WarningAlert(str);
|
|
|
|
goto open_error;
|
|
|
|
}
|
1999-10-03 14:16:26 +00:00
|
|
|
}
|
|
|
|
|
2004-05-09 16:16:05 +00:00
|
|
|
#if ENABLE_TUNTAP
|
|
|
|
// Open TUN/TAP interface
|
|
|
|
if (net_if_type == NET_IF_TUNTAP) {
|
|
|
|
struct ifreq ifr;
|
|
|
|
memset(&ifr, 0, sizeof(ifr));
|
|
|
|
ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
|
|
|
|
strcpy(ifr.ifr_name, "tun%d");
|
|
|
|
if (ioctl(fd, TUNSETIFF, (void *) &ifr) != 0) {
|
|
|
|
sprintf(str, GetString(STR_SHEEP_NET_ATTACH_WARN), strerror(errno));
|
|
|
|
WarningAlert(str);
|
|
|
|
goto open_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get network config script file path
|
|
|
|
net_if_script = PrefsFindString("etherconfig");
|
|
|
|
if (net_if_script == NULL)
|
|
|
|
net_if_script = ETHERCONFIG_FILE_NAME;
|
|
|
|
|
|
|
|
// Start network script up
|
|
|
|
if (net_if_script == NULL) {
|
|
|
|
sprintf(str, GetString(STR_TUN_TAP_CONFIG_WARN), "script not found");
|
|
|
|
WarningAlert(str);
|
|
|
|
goto open_error;
|
|
|
|
}
|
2004-05-09 16:32:12 +00:00
|
|
|
net_if_name = strdup(ifr.ifr_name);
|
2004-05-09 16:16:05 +00:00
|
|
|
if (!execute_network_script("up")) {
|
|
|
|
sprintf(str, GetString(STR_TUN_TAP_CONFIG_WARN), "script execute error");
|
|
|
|
WarningAlert(str);
|
|
|
|
goto open_error;
|
|
|
|
}
|
|
|
|
D(bug("Connected to host network interface: %s\n", net_if_name));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2001-03-29 14:20:55 +00:00
|
|
|
#if defined(__linux__)
|
1999-10-03 14:16:26 +00:00
|
|
|
// Attach sheep_net to selected Ethernet card
|
2004-05-09 16:16:05 +00:00
|
|
|
if (net_if_type == NET_IF_SHEEPNET && ioctl(fd, SIOCSIFLINK, name) < 0) {
|
1999-10-03 14:16:26 +00:00
|
|
|
sprintf(str, GetString(STR_SHEEP_NET_ATTACH_WARN), strerror(errno));
|
|
|
|
WarningAlert(str);
|
|
|
|
goto open_error;
|
|
|
|
}
|
2001-03-29 14:20:55 +00:00
|
|
|
#endif
|
1999-10-03 14:16:26 +00:00
|
|
|
|
|
|
|
// Set nonblocking I/O
|
|
|
|
ioctl(fd, FIONBIO, &nonblock);
|
|
|
|
|
|
|
|
// Get Ethernet address
|
2004-05-09 16:16:05 +00:00
|
|
|
if (net_if_type == NET_IF_ETHERTAP) {
|
1999-10-03 14:16:26 +00:00
|
|
|
pid_t p = getpid(); // If configured for multicast, ethertap requires that the lower 32 bit of the Ethernet address are our PID
|
|
|
|
ether_addr[0] = 0xfe;
|
|
|
|
ether_addr[1] = 0xfd;
|
|
|
|
ether_addr[2] = p >> 24;
|
|
|
|
ether_addr[3] = p >> 16;
|
|
|
|
ether_addr[4] = p >> 8;
|
|
|
|
ether_addr[5] = p;
|
2005-05-13 09:21:21 +00:00
|
|
|
#ifdef HAVE_SLIRP
|
|
|
|
} else if (net_if_type == NET_IF_SLIRP) {
|
|
|
|
ether_addr[0] = 0x52;
|
|
|
|
ether_addr[1] = 0x54;
|
|
|
|
ether_addr[2] = 0x00;
|
|
|
|
ether_addr[3] = 0x12;
|
|
|
|
ether_addr[4] = 0x34;
|
|
|
|
ether_addr[5] = 0x56;
|
|
|
|
#endif
|
1999-10-03 14:16:26 +00:00
|
|
|
} else
|
|
|
|
ioctl(fd, SIOCGIFADDR, ether_addr);
|
|
|
|
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]));
|
|
|
|
|
|
|
|
// Start packet reception thread
|
2001-07-12 19:48:28 +00:00
|
|
|
if (!start_thread())
|
1999-10-03 14:16:26 +00:00
|
|
|
goto open_error;
|
|
|
|
|
|
|
|
// Everything OK
|
2001-07-12 19:48:28 +00:00
|
|
|
return true;
|
1999-10-03 14:16:26 +00:00
|
|
|
|
|
|
|
open_error:
|
2001-07-12 19:48:28 +00:00
|
|
|
stop_thread();
|
|
|
|
|
1999-10-03 14:16:26 +00:00
|
|
|
if (fd > 0) {
|
|
|
|
close(fd);
|
|
|
|
fd = -1;
|
|
|
|
}
|
2005-05-13 09:21:21 +00:00
|
|
|
if (slirp_output_fd >= 0) {
|
|
|
|
close(slirp_output_fd);
|
|
|
|
slirp_output_fd = -1;
|
|
|
|
}
|
2001-07-12 19:48:28 +00:00
|
|
|
return false;
|
1999-10-03 14:16:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Deinitialization
|
|
|
|
*/
|
|
|
|
|
2001-07-12 19:48:28 +00:00
|
|
|
void ether_exit(void)
|
1999-10-03 14:16:26 +00:00
|
|
|
{
|
|
|
|
// Stop reception thread
|
|
|
|
if (thread_active) {
|
|
|
|
pthread_cancel(ether_thread);
|
|
|
|
pthread_join(ether_thread, NULL);
|
|
|
|
sem_destroy(&int_ack);
|
|
|
|
thread_active = false;
|
|
|
|
}
|
|
|
|
|
2004-05-09 16:32:12 +00:00
|
|
|
// Shut down TUN/TAP interface
|
|
|
|
if (net_if_type == NET_IF_TUNTAP)
|
|
|
|
execute_network_script("down");
|
|
|
|
|
|
|
|
// Free TUN/TAP device name
|
|
|
|
if (net_if_name)
|
|
|
|
free(net_if_name);
|
|
|
|
|
1999-10-03 14:16:26 +00:00
|
|
|
// Close sheep_net device
|
|
|
|
if (fd > 0)
|
|
|
|
close(fd);
|
2005-05-13 09:21:21 +00:00
|
|
|
|
|
|
|
// Close slirp output buffer
|
|
|
|
if (slirp_output_fd > 0)
|
|
|
|
close(slirp_output_fd);
|
1999-10-03 14:16:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reset
|
|
|
|
*/
|
|
|
|
|
2001-07-13 15:39:25 +00:00
|
|
|
void ether_reset(void)
|
1999-10-03 14:16:26 +00:00
|
|
|
{
|
2001-07-13 15:39:25 +00:00
|
|
|
net_protocols.clear();
|
1999-10-03 14:16:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add multicast address
|
|
|
|
*/
|
|
|
|
|
|
|
|
int16 ether_add_multicast(uint32 pb)
|
|
|
|
{
|
2005-05-13 09:21:21 +00:00
|
|
|
switch (net_if_type) {
|
|
|
|
case NET_IF_ETHERTAP:
|
|
|
|
case NET_IF_SHEEPNET:
|
|
|
|
if (ioctl(fd, SIOCADDMULTI, Mac2HostAddr(pb + eMultiAddr)) < 0) {
|
|
|
|
D(bug("WARNING: Couldn't enable multicast address\n"));
|
|
|
|
if (net_if_type == NET_IF_ETHERTAP)
|
|
|
|
return noErr;
|
|
|
|
else
|
|
|
|
return eMultiErr;
|
|
|
|
}
|
|
|
|
default:
|
1999-10-03 14:16:26 +00:00
|
|
|
return noErr;
|
2005-05-13 09:21:21 +00:00
|
|
|
}
|
1999-10-03 14:16:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Delete multicast address
|
|
|
|
*/
|
|
|
|
|
|
|
|
int16 ether_del_multicast(uint32 pb)
|
|
|
|
{
|
2005-05-13 09:21:21 +00:00
|
|
|
switch (net_if_type) {
|
|
|
|
case NET_IF_ETHERTAP:
|
|
|
|
case NET_IF_SHEEPNET:
|
|
|
|
if (ioctl(fd, SIOCDELMULTI, Mac2HostAddr(pb + eMultiAddr)) < 0) {
|
|
|
|
D(bug("WARNING: Couldn't disable multicast address\n"));
|
|
|
|
return eMultiErr;
|
|
|
|
}
|
|
|
|
default:
|
1999-10-03 14:16:26 +00:00
|
|
|
return noErr;
|
2005-05-13 09:21:21 +00:00
|
|
|
}
|
1999-10-03 14:16:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Attach protocol handler
|
|
|
|
*/
|
|
|
|
|
|
|
|
int16 ether_attach_ph(uint16 type, uint32 handler)
|
|
|
|
{
|
2001-07-13 15:39:25 +00:00
|
|
|
if (net_protocols.find(type) != net_protocols.end())
|
1999-10-03 14:16:26 +00:00
|
|
|
return lapProtErr;
|
2001-07-13 15:39:25 +00:00
|
|
|
net_protocols[type] = handler;
|
|
|
|
return noErr;
|
1999-10-03 14:16:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Detach protocol handler
|
|
|
|
*/
|
|
|
|
|
|
|
|
int16 ether_detach_ph(uint16 type)
|
|
|
|
{
|
2001-07-13 15:39:25 +00:00
|
|
|
if (net_protocols.erase(type) == 0)
|
1999-10-03 14:16:26 +00:00
|
|
|
return lapProtErr;
|
2001-07-13 15:39:25 +00:00
|
|
|
return noErr;
|
1999-10-03 14:16:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Transmit raw ethernet packet
|
|
|
|
*/
|
|
|
|
|
|
|
|
int16 ether_write(uint32 wds)
|
|
|
|
{
|
|
|
|
// Copy packet to buffer
|
|
|
|
uint8 packet[1516], *p = packet;
|
|
|
|
int len = 0;
|
2001-03-29 14:20:55 +00:00
|
|
|
#if defined(__linux__)
|
2004-05-09 16:16:05 +00:00
|
|
|
if (net_if_type == NET_IF_ETHERTAP) {
|
2001-03-29 14:20:55 +00:00
|
|
|
*p++ = 0; // Linux ethertap discards the first 2 bytes
|
1999-10-03 14:16:26 +00:00
|
|
|
*p++ = 0;
|
|
|
|
len += 2;
|
|
|
|
}
|
2001-03-29 14:20:55 +00:00
|
|
|
#endif
|
2001-07-12 19:48:28 +00:00
|
|
|
len += ether_wds_to_buffer(wds, p);
|
1999-10-03 14:16:26 +00:00
|
|
|
|
|
|
|
#if MONITOR
|
|
|
|
bug("Sending Ethernet packet:\n");
|
|
|
|
for (int i=0; i<len; i++) {
|
|
|
|
bug("%02x ", packet[i]);
|
|
|
|
}
|
|
|
|
bug("\n");
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// Transmit packet
|
2005-05-13 09:21:21 +00:00
|
|
|
#ifdef HAVE_SLIRP
|
|
|
|
if (net_if_type == NET_IF_SLIRP) {
|
|
|
|
slirp_input(packet, len);
|
|
|
|
return noErr;
|
|
|
|
} else
|
|
|
|
#endif
|
1999-10-03 14:16:26 +00:00
|
|
|
if (write(fd, packet, len) < 0) {
|
|
|
|
D(bug("WARNING: Couldn't transmit packet\n"));
|
|
|
|
return excessCollsns;
|
|
|
|
} else
|
|
|
|
return noErr;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-07-12 19:48:28 +00:00
|
|
|
/*
|
|
|
|
* Start UDP packet reception thread
|
|
|
|
*/
|
|
|
|
|
|
|
|
bool ether_start_udp_thread(int socket_fd)
|
|
|
|
{
|
|
|
|
fd = socket_fd;
|
|
|
|
udp_tunnel = true;
|
|
|
|
return start_thread();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Stop UDP packet reception thread
|
|
|
|
*/
|
|
|
|
|
|
|
|
void ether_stop_udp_thread(void)
|
|
|
|
{
|
|
|
|
stop_thread();
|
|
|
|
fd = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-05-13 09:21:21 +00:00
|
|
|
/*
|
|
|
|
* SLIRP output buffer glue
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_SLIRP
|
|
|
|
int slirp_can_output(void)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void slirp_output(const uint8 *packet, int len)
|
|
|
|
{
|
|
|
|
write(slirp_output_fd, packet, len);
|
|
|
|
}
|
|
|
|
|
|
|
|
void *slirp_receive_func(void *arg)
|
|
|
|
{
|
|
|
|
for (;;) {
|
|
|
|
// Wait for packets to arrive
|
|
|
|
fd_set rfds, wfds, xfds;
|
|
|
|
int nfds;
|
|
|
|
struct timeval tv;
|
|
|
|
|
|
|
|
nfds = -1;
|
|
|
|
FD_ZERO(&rfds);
|
|
|
|
FD_ZERO(&wfds);
|
|
|
|
FD_ZERO(&xfds);
|
|
|
|
slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
|
|
|
|
tv.tv_sec = 0;
|
|
|
|
tv.tv_usec = 16667;
|
|
|
|
if (select(nfds + 1, &rfds, &wfds, &xfds, &tv) >= 0)
|
|
|
|
slirp_select_poll(&rfds, &wfds, &xfds);
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
int slirp_can_output(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void slirp_output(const uint8 *packet, int len)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2005-05-13 17:43:38 +00:00
|
|
|
/*
|
|
|
|
* Wait for data to arrive
|
|
|
|
*/
|
|
|
|
|
|
|
|
static inline int poll_fd(int fd)
|
|
|
|
{
|
|
|
|
#ifdef HAVE_POLL
|
|
|
|
struct pollfd pf = {fd, POLLIN, 0};
|
|
|
|
return poll(&pf, 1, -1);
|
|
|
|
#else
|
|
|
|
fd_set rfds;
|
|
|
|
FD_ZERO(&rfds);
|
|
|
|
FD_SET(fd, &rfds);
|
|
|
|
return select(1, &rfds, NULL, NULL, NULL);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-10-03 14:16:26 +00:00
|
|
|
/*
|
|
|
|
* Packet reception thread
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void *receive_func(void *arg)
|
|
|
|
{
|
|
|
|
for (;;) {
|
|
|
|
|
|
|
|
// Wait for packets to arrive
|
2005-05-13 17:43:38 +00:00
|
|
|
int res = poll_fd(fd);
|
1999-10-03 14:16:26 +00:00
|
|
|
if (res <= 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Trigger Ethernet interrupt
|
|
|
|
D(bug(" packet received, triggering Ethernet interrupt\n"));
|
|
|
|
SetInterruptFlag(INTFLAG_ETHER);
|
|
|
|
TriggerInterrupt();
|
|
|
|
|
|
|
|
// Wait for interrupt acknowledge by EtherInterrupt()
|
|
|
|
sem_wait(&int_ack);
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ethernet interrupt - activate deferred tasks to call IODone or protocol handlers
|
|
|
|
*/
|
|
|
|
|
|
|
|
void EtherInterrupt(void)
|
|
|
|
{
|
|
|
|
D(bug("EtherIRQ\n"));
|
|
|
|
|
|
|
|
// Call protocol handler for received packets
|
2005-03-19 17:43:03 +00:00
|
|
|
EthernetPacket ether_packet;
|
|
|
|
uint32 packet = ether_packet.addr();
|
2001-07-12 19:48:28 +00:00
|
|
|
ssize_t length;
|
1999-10-03 14:16:26 +00:00
|
|
|
for (;;) {
|
|
|
|
|
2001-07-12 19:48:28 +00:00
|
|
|
if (udp_tunnel) {
|
|
|
|
|
|
|
|
// Read packet from socket
|
|
|
|
struct sockaddr_in from;
|
|
|
|
socklen_t from_len = sizeof(from);
|
2005-03-19 17:43:03 +00:00
|
|
|
length = recvfrom(fd, Mac2HostAddr(packet), 1514, 0, (struct sockaddr *)&from, &from_len);
|
2001-07-12 19:48:28 +00:00
|
|
|
if (length < 14)
|
|
|
|
break;
|
|
|
|
ether_udp_read(packet, length, &from);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
// Read packet from sheep_net device
|
2001-03-29 14:20:55 +00:00
|
|
|
#if defined(__linux__)
|
2005-03-19 17:43:03 +00:00
|
|
|
length = read(fd, Mac2HostAddr(packet), net_if_type == NET_IF_ETHERTAP ? 1516 : 1514);
|
2001-03-29 14:20:55 +00:00
|
|
|
#else
|
2005-03-19 17:43:03 +00:00
|
|
|
length = read(fd, Mac2HostAddr(packet), 1514);
|
2001-03-29 14:20:55 +00:00
|
|
|
#endif
|
2001-07-12 19:48:28 +00:00
|
|
|
if (length < 14)
|
|
|
|
break;
|
1999-10-03 14:16:26 +00:00
|
|
|
|
|
|
|
#if MONITOR
|
2001-07-12 19:48:28 +00:00
|
|
|
bug("Receiving Ethernet packet:\n");
|
|
|
|
for (int i=0; i<length; i++) {
|
2005-03-19 17:43:03 +00:00
|
|
|
bug("%02x ", ReadMacInt8(packet + i));
|
2001-07-12 19:48:28 +00:00
|
|
|
}
|
|
|
|
bug("\n");
|
1999-10-03 14:16:26 +00:00
|
|
|
#endif
|
|
|
|
|
2001-07-12 19:48:28 +00:00
|
|
|
// Pointer to packet data (Ethernet header)
|
2005-03-19 17:43:03 +00:00
|
|
|
uint32 p = packet;
|
2001-03-29 14:20:55 +00:00
|
|
|
#if defined(__linux__)
|
2004-05-09 16:16:05 +00:00
|
|
|
if (net_if_type == NET_IF_ETHERTAP) {
|
2001-07-12 19:48:28 +00:00
|
|
|
p += 2; // Linux ethertap has two random bytes before the packet
|
|
|
|
length -= 2;
|
|
|
|
}
|
2001-03-29 14:20:55 +00:00
|
|
|
#endif
|
1999-10-03 14:16:26 +00:00
|
|
|
|
2001-07-12 19:48:28 +00:00
|
|
|
// Get packet type
|
2005-03-19 17:43:03 +00:00
|
|
|
uint16 type = ReadMacInt16(p + 12);
|
2001-07-12 19:48:28 +00:00
|
|
|
|
|
|
|
// Look for protocol
|
2001-07-13 15:39:25 +00:00
|
|
|
uint16 search_type = (type <= 1500 ? 0 : type);
|
|
|
|
if (net_protocols.find(search_type) == net_protocols.end())
|
2001-07-12 19:48:28 +00:00
|
|
|
continue;
|
2001-07-13 15:39:25 +00:00
|
|
|
uint32 handler = net_protocols[search_type];
|
2001-07-12 19:48:28 +00:00
|
|
|
|
|
|
|
// No default handler
|
2001-07-13 15:39:25 +00:00
|
|
|
if (handler == 0)
|
2001-07-12 19:48:28 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
// Copy header to RHA
|
2005-03-19 17:43:03 +00:00
|
|
|
Mac2Mac_memcpy(ether_data + ed_RHA, p, 14);
|
2001-07-12 19:48:28 +00:00
|
|
|
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)
|
2005-03-19 17:43:03 +00:00
|
|
|
r.a[0] = p + 14; // Pointer to packet (Mac address, for ReadPacket)
|
2001-07-12 19:48:28 +00:00
|
|
|
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
|
2001-07-13 15:39:25 +00:00
|
|
|
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);
|
2001-07-12 19:48:28 +00:00
|
|
|
}
|
1999-10-03 14:16:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Acknowledge interrupt to reception thread
|
|
|
|
D(bug(" EtherIRQ done\n"));
|
|
|
|
sem_post(&int_ack);
|
|
|
|
}
|