Unix/Linux/ether_linux.cpp

/*
 *  ether_linux.cpp - SheepShaver Ethernet Device Driver (DLPI), Linux specific stuff
 *
 *  SheepShaver (C) 1997-2004 Marc Hellwig and 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
 */

#include "sysdeps.h"

#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <sys/poll.h>
#include <sys/wait.h>
#include <stdio.h>
#include <string.h>

#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

#include "main.h"
#include "macos_util.h"
#include "prefs.h"
#include "user_strings.h"
#include "ether.h"
#include "ether_defs.h"

#define DEBUG 0
#include "debug.h"

#define STATISTICS 0
#define MONITOR 0


// Ethernet device types
enum {
        NET_IF_SHEEPNET,
        NET_IF_ETHERTAP,
        NET_IF_TUNTAP,
};

// Constants
static const char ETHERCONFIG_FILE_NAME[] = DATADIR "/tunconfig";

// Global variables
static int fd = -1;                                     // fd of sheep_net device

static pthread_t ether_thread;          // Packet reception thread
static bool thread_active = false;      // Flag: Packet reception thread installed

static sem_t int_ack;                           // Interrupt acknowledge semaphore
static uint8 ether_addr[6];                     // Our Ethernet address

static bool net_open = false;           // Flag: initialization succeeded, network device open
static int net_if_type = -1;            // Ethernet device type
static char *net_if_name;                       // TUN/TAP device name
static const char *net_if_script;       // Network config script


// Prototypes
static void *receive_func(void *arg);


/*
 *  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;
                        args[1] = net_if_name;
                        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;
}


/*
 *  Initialize ethernet
 */

void EtherInit(void)
{
        int nonblock = 1;
        char str[256];

        // Do nothing if the user disabled the network
        if (PrefsFindBool("nonet"))
                return;

        // Do nothing if no Ethernet device specified
        const char *name = PrefsFindString("ether");
        if (name == NULL)
                return;

        // Determine Ether 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;
#endif
        else
                net_if_type = NET_IF_SHEEPNET;

        // Open sheep_net or ethertap device
        char dev_name[16];
        switch (net_if_type) {
        case NET_IF_ETHERTAP:
                sprintf(dev_name, "/dev/%s", name);
                break;
        case NET_IF_TUNTAP:     
                strcpy(dev_name, "/dev/net/tun");
                break;
        case NET_IF_SHEEPNET:
                strcpy(dev_name, "/dev/sheep_net");
                break;
        }
        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;
        }

#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;
                }
                net_if_name = strdup(ifr.ifr_name);
                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

        // Attach to selected Ethernet card
        if (net_if_type == NET_IF_SHEEPNET && ioctl(fd, SIOCSIFLINK, name) < 0) {
                sprintf(str, GetString(STR_SHEEP_NET_ATTACH_WARN), strerror(errno));
                WarningAlert(str);
                goto open_error;
        }

        // Set nonblocking I/O
        ioctl(fd, FIONBIO, &nonblock);

        // Get Ethernet address
        if (net_if_type == NET_IF_ETHERTAP) {
                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;
        } 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
        if (sem_init(&int_ack, 0, 0) < 0) {
                WarningAlert("WARNING: Cannot init semaphore");
                goto open_error;
        }
        thread_active = (pthread_create(&ether_thread, NULL, receive_func, NULL) == 0);
        if (!thread_active) {
                WarningAlert("WARNING: Cannot start Ethernet thread");
                goto open_error;
        }

        // Everything OK
        net_open = true;
        return;

open_error:
        if (thread_active) {
                pthread_cancel(ether_thread);
                pthread_join(ether_thread, NULL);
                sem_destroy(&int_ack);
                thread_active = false;
        }
        if (fd > 0) {
                close(fd);
                fd = -1;
        }
}


/*
 *  Exit ethernet
 */

void EtherExit(void)
{
        // Stop reception thread
        if (thread_active) {
                pthread_cancel(ether_thread);
                pthread_join(ether_thread, NULL);
                sem_destroy(&int_ack);
                thread_active = false;
        }

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

        // Close sheep_net device
        if (fd > 0)
                close(fd);

#if STATISTICS
        // Show statistics
        printf("%ld messages put on write queue\n", num_wput);
        printf("%ld error acks\n", num_error_acks);
        printf("%ld packets transmitted (%ld raw, %ld normal)\n", num_tx_packets, num_tx_raw_packets, num_tx_normal_packets);
        printf("%ld tx packets dropped because buffer full\n", num_tx_buffer_full);
        printf("%ld packets received\n", num_rx_packets);
        printf("%ld packets passed upstream (%ld Fast Path, %ld normal)\n", num_rx_fastpath + num_unitdata_ind, num_rx_fastpath, num_unitdata_ind);
        printf("EtherIRQ called %ld times\n", num_ether_irq);
        printf("%ld rx packets dropped due to low memory\n", num_rx_no_mem);
        printf("%ld rx packets dropped because no stream found\n", num_rx_dropped);
        printf("%ld rx packets dropped because stream not ready\n", num_rx_stream_not_ready);
        printf("%ld rx packets dropped because no memory for unitdata_ind\n", num_rx_no_unitdata_mem);
#endif
}


/*
 *  Get ethernet hardware address
 */

void AO_get_ethernet_address(uint8 *addr)
{
        if (net_open) {
                OTCopy48BitAddress(ether_addr, addr);
        } else {
                addr[0] = 0x12;
                addr[1] = 0x34;
                addr[2] = 0x56;
                addr[3] = 0x78;
                addr[4] = 0x9a;
                addr[5] = 0xbc;
        }
        D(bug("AO_get_ethernet_address: got address %02x%02x%02x%02x%02x%02x\n", addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]));
}


/*
 *  Enable multicast address
 */

void AO_enable_multicast(uint8 *addr)
{
        D(bug("AO_enable_multicast\n"));
        if (net_open) {
                if (net_if_type != NET_IF_TUNTAP && ioctl(fd, SIOCADDMULTI, addr) < 0) {
                        D(bug("WARNING: couldn't enable multicast address\n"));
                }
        }
}


/*
 *  Disable multicast address
 */

void AO_disable_multicast(uint8 *addr)
{
        D(bug("AO_disable_multicast\n"));
        if (net_open) {
                if (net_if_type != NET_IF_TUNTAP && ioctl(fd, SIOCDELMULTI, addr) < 0) {
                        D(bug("WARNING: couldn't disable multicast address\n"));
                }
        }
}


/*
 *  Transmit one packet
 */

void AO_transmit_packet(mblk_t *mp)
{
        D(bug("AO_transmit_packet\n"));
        if (net_open) {

                // Copy packet to buffer
                uint8 packet[1516], *p = packet;
                int len = 0;
                if (net_if_type == NET_IF_ETHERTAP) {
                        *p++ = 0;       // Ethertap discards the first 2 bytes
                        *p++ = 0;
                        len += 2;
                }
                while (mp) {
                        uint32 size = mp->b_wptr - mp->b_rptr;
                        memcpy(p, mp->b_rptr, size);
                        len += size;
                        p += size;
                        mp = mp->b_cont;
                }

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

                // Transmit packet
                if (write(fd, packet, len) < 0) {
                        D(bug("WARNING: couldn't transmit packet\n"));
                        num_tx_buffer_full++;
                } else
                        num_tx_packets++;
        }
}


/*
 *  Packet reception thread
 */

static void *receive_func(void *arg)
{
        for (;;) {

                // Wait for packets to arrive
                struct pollfd pf = {fd, POLLIN, 0};
                int res = poll(&pf, 1, -1);
                if (res <= 0)
                        break;

                if (ether_driver_opened) {
                        // 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);
                } else
                        usleep(20000);
        }
        return NULL;
}


/*
 *  Ethernet interrupt
 */

void EtherIRQ(void)
{
        D(bug("EtherIRQ\n"));
        num_ether_irq++;
        OTEnterInterrupt();

        // Send received packets to OpenTransport
        uint8 packet[1516];
        for (;;) {

                if (net_if_type != NET_IF_SHEEPNET) {

                        // Read packet from ethertap device
                        ssize_t size = read(fd, packet, net_if_type == NET_IF_ETHERTAP ? 1516 : 1514);
                        if (size < 14)
                                break;

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

                        // Pointer to packet data (Ethernet header)
                        uint8 *p = packet;
                        if (net_if_type == NET_IF_ETHERTAP) {
                                p += 2; // Ethertap has two random bytes before the packet
                                size -= 2;
                        }

                        // Wrap packet in message block
                        num_rx_packets++;
                        mblk_t *mp;
                        if ((mp = allocb(size, 0)) != NULL) {
                                D(bug(" packet data at %p\n", (void *)mp->b_rptr));
                                memcpy(mp->b_rptr, p, size);
                                mp->b_wptr += size;
                                ether_packet_received(mp);
                        } else {
                                D(bug("WARNING: Cannot allocate mblk for received packet\n"));
                                num_rx_no_mem++;
                        }

                } else {

                        // Get size of first packet
                        int size = 0;
                        if (ioctl(fd, FIONREAD, &size) < 0 || size == 0)
                                break;

                        // Discard packets which are too short
                        if (size < 14) {
                                uint8 dummy[14];
                                read(fd, dummy, size);
                                continue;
                        }

                        // Truncate packets which are too long
                        if (size > 1514)
                                size = 1514;

                        // Read packet and wrap it in message block
                        num_rx_packets++;
                        mblk_t *mp;
                        if ((mp = allocb(size, 0)) != NULL) {
                                D(bug(" packet data at %p\n", (void *)mp->b_rptr));
                                read(fd, mp->b_rptr, size);
#if MONITOR
                                bug("Receiving Ethernet packet:\n");
                                for (int i=0; i<size; i++) {
                                        bug("%02x ", ((uint8 *)mp->b_rptr)[i]);
                                }
                                bug("\n");
#endif
                                mp->b_wptr += size;
                                ether_packet_received(mp);
                        } else {
                                D(bug("WARNING: Cannot allocate mblk for received packet\n"));
                                num_rx_no_mem++;
                        }
                }
        }
        OTLeaveInterrupt();

        // Acknowledge interrupt to reception thread
        D(bug(" EtherIRQ done\n"));
        sem_post(&int_ack);
}
Revision:	1.5
Committed:	2004-05-12T11:42:12Z (20 years, 6 months ago) by gbeauche
Branch:	MAIN
Changes since 1.4:	+3 -3 lines
Log Message:	Typos. In EtherIRQ sheep_net case, really grab size bytes from device
#	User	Rev	Content
1	cebix	1.1	/*
2			* ether_linux.cpp - SheepShaver Ethernet Device Driver (DLPI), Linux specific stuff
3			*
4	cebix	1.2	* SheepShaver (C) 1997-2004 Marc Hellwig and 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	gbeauche	1.3	#include "sysdeps.h"
22
23	cebix	1.1	#include <pthread.h>
24			#include <semaphore.h>
25			#include <unistd.h>
26			#include <fcntl.h>
27			#include <errno.h>
28			#include <sys/ioctl.h>
29			#include <sys/poll.h>
30	gbeauche	1.3	#include <sys/wait.h>
31	cebix	1.1	#include <stdio.h>
32			#include <string.h>
33
34	gbeauche	1.3	#if defined(HAVE_LINUX_IF_H) && defined(HAVE_LINUX_IF_TUN_H)
35			#include <linux/if.h>
36			#include <linux/if_tun.h>
37			#endif
38
39			#if defined(HAVE_NET_IF_H) && defined(HAVE_NET_IF_TUN_H)
40			#include <net/if.h>
41			#include <net/if_tun.h>
42			#endif
43
44	cebix	1.1	#include "main.h"
45			#include "macos_util.h"
46			#include "prefs.h"
47			#include "user_strings.h"
48			#include "ether.h"
49			#include "ether_defs.h"
50
51			#define DEBUG 0
52			#include "debug.h"
53
54			#define STATISTICS 0
55			#define MONITOR 0
56
57
58	gbeauche	1.3	// Ethernet device types
59			enum {
60			NET_IF_SHEEPNET,
61			NET_IF_ETHERTAP,
62			NET_IF_TUNTAP,
63			};
64
65			// Constants
66			static const char ETHERCONFIG_FILE_NAME[] = DATADIR "/tunconfig";
67
68	cebix	1.1	// Global variables
69			static int fd = -1; // fd of sheep_net device
70
71			static pthread_t ether_thread; // Packet reception thread
72			static bool thread_active = false; // Flag: Packet reception thread installed
73
74			static sem_t int_ack; // Interrupt acknowledge semaphore
75			static uint8 ether_addr[6]; // Our Ethernet address
76
77			static bool net_open = false; // Flag: initialization succeeded, network device open
78	gbeauche	1.3	static int net_if_type = -1; // Ethernet device type
79			static char *net_if_name; // TUN/TAP device name
80			static const char *net_if_script; // Network config script
81	cebix	1.1
82
83			// Prototypes
84			static void receive_func(void arg);
85
86
87			/*
88	gbeauche	1.3	* Execute network script up\|down
89			*/
90
91			static bool execute_network_script(const char *action)
92			{
93			if (net_if_script == NULL \|\| net_if_name == NULL)
94			return false;
95
96			int pid = fork();
97			if (pid >= 0) {
98			if (pid == 0) {
99			char *args[4];
100			args[0] = (char *)net_if_script;
101			args[1] = net_if_name;
102			args[2] = (char *)action;
103			args[3] = NULL;
104			execv(net_if_script, args);
105			exit(1);
106			}
107			int status;
108			while (waitpid(pid, &status, 0) != pid);
109			return WIFEXITED(status) && WEXITSTATUS(status) == 0;
110			}
111
112			return false;
113			}
114
115
116			/*
117	cebix	1.1	* Initialize ethernet
118			*/
119
120			void EtherInit(void)
121			{
122			int nonblock = 1;
123			char str[256];
124
125			// Do nothing if the user disabled the network
126			if (PrefsFindBool("nonet"))
127			return;
128
129			// Do nothing if no Ethernet device specified
130			const char *name = PrefsFindString("ether");
131			if (name == NULL)
132			return;
133
134	gbeauche	1.3	// Determine Ether device type
135			net_if_type = -1;
136			if (strncmp(name, "tap", 3) == 0)
137			net_if_type = NET_IF_ETHERTAP;
138			#if ENABLE_TUNTAP
139			else if (strcmp(name, "tun") == 0)
140			net_if_type = NET_IF_TUNTAP;
141			#endif
142			else
143			net_if_type = NET_IF_SHEEPNET;
144	cebix	1.1
145			// Open sheep_net or ethertap device
146			char dev_name[16];
147	gbeauche	1.3	switch (net_if_type) {
148			case NET_IF_ETHERTAP:
149	cebix	1.1	sprintf(dev_name, "/dev/%s", name);
150	gbeauche	1.3	break;
151	gbeauche	1.5	case NET_IF_TUNTAP:
152			strcpy(dev_name, "/dev/net/tun");
153	gbeauche	1.3	break;
154			case NET_IF_SHEEPNET:
155	cebix	1.1	strcpy(dev_name, "/dev/sheep_net");
156	gbeauche	1.3	break;
157			}
158	cebix	1.1	fd = open(dev_name, O_RDWR);
159			if (fd < 0) {
160			sprintf(str, GetString(STR_NO_SHEEP_NET_DRIVER_WARN), dev_name, strerror(errno));
161			WarningAlert(str);
162			goto open_error;
163			}
164
165	gbeauche	1.3	#if ENABLE_TUNTAP
166			// Open TUN/TAP interface
167			if (net_if_type == NET_IF_TUNTAP) {
168			struct ifreq ifr;
169			memset(&ifr, 0, sizeof(ifr));
170			ifr.ifr_flags = IFF_TAP \| IFF_NO_PI;
171			strcpy(ifr.ifr_name, "tun%d");
172			if (ioctl(fd, TUNSETIFF, (void *) &ifr) != 0) {
173			sprintf(str, GetString(STR_SHEEP_NET_ATTACH_WARN), strerror(errno));
174			WarningAlert(str);
175			goto open_error;
176			}
177
178			// Get network config script file path
179			net_if_script = PrefsFindString("etherconfig");
180			if (net_if_script == NULL)
181			net_if_script = ETHERCONFIG_FILE_NAME;
182
183			// Start network script up
184			if (net_if_script == NULL) {
185			sprintf(str, GetString(STR_TUN_TAP_CONFIG_WARN), "script not found");
186			WarningAlert(str);
187			goto open_error;
188			}
189			net_if_name = strdup(ifr.ifr_name);
190			if (!execute_network_script("up")) {
191			sprintf(str, GetString(STR_TUN_TAP_CONFIG_WARN), "script execute error");
192			WarningAlert(str);
193			goto open_error;
194			}
195			D(bug("Connected to host network interface: %s\n", net_if_name));
196			}
197			#endif
198
199	cebix	1.1	// Attach to selected Ethernet card
200	gbeauche	1.3	if (net_if_type == NET_IF_SHEEPNET && ioctl(fd, SIOCSIFLINK, name) < 0) {
201	cebix	1.1	sprintf(str, GetString(STR_SHEEP_NET_ATTACH_WARN), strerror(errno));
202			WarningAlert(str);
203			goto open_error;
204			}
205
206			// Set nonblocking I/O
207			ioctl(fd, FIONBIO, &nonblock);
208
209			// Get Ethernet address
210	gbeauche	1.3	if (net_if_type == NET_IF_ETHERTAP) {
211	cebix	1.1	pid_t p = getpid(); // If configured for multicast, ethertap requires that the lower 32 bit of the Ethernet address are our PID
212			ether_addr[0] = 0xfe;
213			ether_addr[1] = 0xfd;
214			ether_addr[2] = p >> 24;
215			ether_addr[3] = p >> 16;
216			ether_addr[4] = p >> 8;
217			ether_addr[5] = p;
218			} else
219			ioctl(fd, SIOCGIFADDR, ether_addr);
220			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]));
221
222			// Start packet reception thread
223			if (sem_init(&int_ack, 0, 0) < 0) {
224			WarningAlert("WARNING: Cannot init semaphore");
225			goto open_error;
226			}
227			thread_active = (pthread_create(&ether_thread, NULL, receive_func, NULL) == 0);
228			if (!thread_active) {
229			WarningAlert("WARNING: Cannot start Ethernet thread");
230			goto open_error;
231			}
232
233			// Everything OK
234			net_open = true;
235			return;
236
237			open_error:
238			if (thread_active) {
239			pthread_cancel(ether_thread);
240			pthread_join(ether_thread, NULL);
241			sem_destroy(&int_ack);
242			thread_active = false;
243			}
244			if (fd > 0) {
245			close(fd);
246			fd = -1;
247			}
248			}
249
250
251			/*
252			* Exit ethernet
253			*/
254
255			void EtherExit(void)
256			{
257			// Stop reception thread
258			if (thread_active) {
259			pthread_cancel(ether_thread);
260			pthread_join(ether_thread, NULL);
261			sem_destroy(&int_ack);
262			thread_active = false;
263			}
264
265	gbeauche	1.3	// Shut down TUN/TAP interface
266			if (net_if_type == NET_IF_TUNTAP)
267			execute_network_script("down");
268
269			// Free TUN/TAP device name
270			if (net_if_name)
271			free(net_if_name);
272
273	cebix	1.1	// Close sheep_net device
274			if (fd > 0)
275			close(fd);
276
277			#if STATISTICS
278			// Show statistics
279			printf("%ld messages put on write queue\n", num_wput);
280			printf("%ld error acks\n", num_error_acks);
281			printf("%ld packets transmitted (%ld raw, %ld normal)\n", num_tx_packets, num_tx_raw_packets, num_tx_normal_packets);
282			printf("%ld tx packets dropped because buffer full\n", num_tx_buffer_full);
283			printf("%ld packets received\n", num_rx_packets);
284			printf("%ld packets passed upstream (%ld Fast Path, %ld normal)\n", num_rx_fastpath + num_unitdata_ind, num_rx_fastpath, num_unitdata_ind);
285			printf("EtherIRQ called %ld times\n", num_ether_irq);
286			printf("%ld rx packets dropped due to low memory\n", num_rx_no_mem);
287			printf("%ld rx packets dropped because no stream found\n", num_rx_dropped);
288			printf("%ld rx packets dropped because stream not ready\n", num_rx_stream_not_ready);
289			printf("%ld rx packets dropped because no memory for unitdata_ind\n", num_rx_no_unitdata_mem);
290			#endif
291			}
292
293
294			/*
295			* Get ethernet hardware address
296			*/
297
298			void AO_get_ethernet_address(uint8 *addr)
299			{
300			if (net_open) {
301			OTCopy48BitAddress(ether_addr, addr);
302			} else {
303			addr[0] = 0x12;
304			addr[1] = 0x34;
305			addr[2] = 0x56;
306			addr[3] = 0x78;
307			addr[4] = 0x9a;
308			addr[5] = 0xbc;
309			}
310			D(bug("AO_get_ethernet_address: got address %02x%02x%02x%02x%02x%02x\n", addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]));
311			}
312
313
314			/*
315			* Enable multicast address
316			*/
317
318			void AO_enable_multicast(uint8 *addr)
319			{
320			D(bug("AO_enable_multicast\n"));
321			if (net_open) {
322	gbeauche	1.3	if (net_if_type != NET_IF_TUNTAP && ioctl(fd, SIOCADDMULTI, addr) < 0) {
323	cebix	1.1	D(bug("WARNING: couldn't enable multicast address\n"));
324			}
325			}
326			}
327
328
329			/*
330			* Disable multicast address
331			*/
332
333			void AO_disable_multicast(uint8 *addr)
334			{
335			D(bug("AO_disable_multicast\n"));
336			if (net_open) {
337	gbeauche	1.3	if (net_if_type != NET_IF_TUNTAP && ioctl(fd, SIOCDELMULTI, addr) < 0) {
338	cebix	1.1	D(bug("WARNING: couldn't disable multicast address\n"));
339			}
340			}
341			}
342
343
344			/*
345			* Transmit one packet
346			*/
347
348			void AO_transmit_packet(mblk_t *mp)
349			{
350			D(bug("AO_transmit_packet\n"));
351			if (net_open) {
352
353			// Copy packet to buffer
354			uint8 packet[1516], *p = packet;
355			int len = 0;
356	gbeauche	1.3	if (net_if_type == NET_IF_ETHERTAP) {
357	cebix	1.1	*p++ = 0; // Ethertap discards the first 2 bytes
358			*p++ = 0;
359			len += 2;
360			}
361			while (mp) {
362			uint32 size = mp->b_wptr - mp->b_rptr;
363			memcpy(p, mp->b_rptr, size);
364			len += size;
365			p += size;
366			mp = mp->b_cont;
367			}
368
369			#if MONITOR
370			bug("Sending Ethernet packet:\n");
371			for (int i=0; i<len; i++) {
372			bug("%02x ", packet[i]);
373			}
374			bug("\n");
375			#endif
376
377			// Transmit packet
378			if (write(fd, packet, len) < 0) {
379			D(bug("WARNING: couldn't transmit packet\n"));
380			num_tx_buffer_full++;
381			} else
382			num_tx_packets++;
383			}
384			}
385
386
387			/*
388			* Packet reception thread
389			*/
390
391			static void receive_func(void arg)
392			{
393			for (;;) {
394
395			// Wait for packets to arrive
396			struct pollfd pf = {fd, POLLIN, 0};
397			int res = poll(&pf, 1, -1);
398			if (res <= 0)
399			break;
400
401			if (ether_driver_opened) {
402			// Trigger Ethernet interrupt
403			D(bug(" packet received, triggering Ethernet interrupt\n"));
404			SetInterruptFlag(INTFLAG_ETHER);
405			TriggerInterrupt();
406
407			// Wait for interrupt acknowledge by EtherInterrupt()
408			sem_wait(&int_ack);
409			} else
410			usleep(20000);
411			}
412			return NULL;
413			}
414
415
416			/*
417			* Ethernet interrupt
418			*/
419
420			void EtherIRQ(void)
421			{
422			D(bug("EtherIRQ\n"));
423			num_ether_irq++;
424			OTEnterInterrupt();
425
426			// Send received packets to OpenTransport
427			uint8 packet[1516];
428			for (;;) {
429
430	gbeauche	1.3	if (net_if_type != NET_IF_SHEEPNET) {
431	cebix	1.1
432			// Read packet from ethertap device
433	gbeauche	1.3	ssize_t size = read(fd, packet, net_if_type == NET_IF_ETHERTAP ? 1516 : 1514);
434	cebix	1.1	if (size < 14)
435			break;
436
437			#if MONITOR
438			bug("Receiving Ethernet packet:\n");
439			for (int i=0; i<size; i++) {
440			bug("%02x ", packet[i]);
441			}
442			bug("\n");
443			#endif
444
445			// Pointer to packet data (Ethernet header)
446	gbeauche	1.3	uint8 *p = packet;
447			if (net_if_type == NET_IF_ETHERTAP) {
448			p += 2; // Ethertap has two random bytes before the packet
449			size -= 2;
450			}
451	cebix	1.1
452			// Wrap packet in message block
453			num_rx_packets++;
454			mblk_t *mp;
455			if ((mp = allocb(size, 0)) != NULL) {
456	gbeauche	1.4	D(bug(" packet data at %p\n", (void *)mp->b_rptr));
457	cebix	1.1	memcpy(mp->b_rptr, p, size);
458			mp->b_wptr += size;
459			ether_packet_received(mp);
460			} else {
461			D(bug("WARNING: Cannot allocate mblk for received packet\n"));
462			num_rx_no_mem++;
463			}
464
465			} else {
466
467			// Get size of first packet
468			int size = 0;
469			if (ioctl(fd, FIONREAD, &size) < 0 \|\| size == 0)
470			break;
471
472			// Discard packets which are too short
473			if (size < 14) {
474			uint8 dummy[14];
475			read(fd, dummy, size);
476			continue;
477			}
478
479			// Truncate packets which are too long
480			if (size > 1514)
481			size = 1514;
482
483			// Read packet and wrap it in message block
484			num_rx_packets++;
485			mblk_t *mp;
486			if ((mp = allocb(size, 0)) != NULL) {
487	gbeauche	1.4	D(bug(" packet data at %p\n", (void *)mp->b_rptr));
488	gbeauche	1.5	read(fd, mp->b_rptr, size);
489	cebix	1.1	#if MONITOR
490			bug("Receiving Ethernet packet:\n");
491			for (int i=0; i<size; i++) {
492			bug("%02x ", ((uint8 *)mp->b_rptr)[i]);
493			}
494			bug("\n");
495			#endif
496			mp->b_wptr += size;
497			ether_packet_received(mp);
498			} else {
499			D(bug("WARNING: Cannot allocate mblk for received packet\n"));
500			num_rx_no_mem++;
501			}
502			}
503			}
504			OTLeaveInterrupt();
505
506			// Acknowledge interrupt to reception thread
507			D(bug(" EtherIRQ done\n"));
508			sem_post(&int_ack);
509			}