BeOS/SheepNet/sheep_net.cpp

/*
 *  sheep_net.cpp - Net server add-on for SheepShaver and Basilisk II
 *
 *  SheepShaver (C) 1997-2002 Marc Hellwig and Christian Bauer
 *  Basilisk II (C) 1997-2002 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 <KernelKit.h>
#include <SupportKit.h>
#include <add-ons/net_server/NetDevice.h>
#include <add-ons/net_server/NetProtocol.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <time.h>

#include "sheep_net.h"

#define DEBUG 0

#if DEBUG==1
#define bug pprintf
#elif DEBUG==2
#define bug kprintf
#endif

#if DEBUG
#define D(x) (x)
#else
#define D(x) ;
#endif

static int pprintf(const char* format, ...)
{
        port_id PortNum;
        int len,Ret;
        char Buffer[1024];
        va_list ap;
        
        if ((PortNum = find_port("PortLogger")) == B_NAME_NOT_FOUND)
                return(PortNum);
        for (len=0; len<1024; len++)
                Buffer[len]='\0'; 
        va_start(ap, format);
        vsprintf(Buffer, format, ap);
        Ret = write_port(PortNum, 0, Buffer, strlen(Buffer));
        return(Ret);
}


// Constants
#define NETDUMP_PRIO 1          // Default is 0

const uint32 buffer_size = (sizeof(net_buffer) / B_PAGE_SIZE + 1) * B_PAGE_SIZE;


// SheepNet add-on object
class SheepNetAddOn : public BNetProtocol, BPacketHandler {
public:
        void AddDevice(BNetDevice *dev, const char *name);
        bool PacketReceived(BNetPacket *buf, BNetDevice *dev);
};


// Global variables
static bool shutdown_now = false; 
static bool     active = false;

static thread_id write_thread;                  // Packet writer
static sem_id write_sem;                                // Semaphore to trigger packet writing
static BNetDevice *EtherCard = NULL;    // The Ethernet card we are attached to
static area_id buffer_area;                             // Packet buffer area
static net_buffer *net_buffer_ptr;              // Pointer to packet buffer

static uint32 rd_pos;                                   // Current read position in packet buffer
static uint32 wr_pos;                                   // Current write position in packet buffer


/*
 *  Clear packet buffer
 */

static void clear(void)
{
        int i;
        for (i=0;i<READ_PACKET_COUNT;i++) {
                net_buffer_ptr->read[i].cmd = 0;
                net_buffer_ptr->read[i].length = 0;
                net_buffer_ptr->read[i].card = 0;
                net_buffer_ptr->read[i].reserved = 0;
        }
        for (i=0;i<WRITE_PACKET_COUNT;i++) {
                net_buffer_ptr->write[i].cmd = 0;
                net_buffer_ptr->write[i].length = 0;
                net_buffer_ptr->write[i].card = 0;
                net_buffer_ptr->write[i].reserved = 0;
        }
        rd_pos = wr_pos = 0;
}


/*
 *  Packet writer thread
 */

static status_t write_packet_func(void *arg)
{
        while (!shutdown_now) {

                // Read and execute command
                net_packet *p = &net_buffer_ptr->write[wr_pos];
                while (p->cmd & IN_USE) {
                        D(bug("wp: %d\n", wr_pos));
                        switch (p->cmd >> 8) {

                                case ACTIVATE_SHEEP_NET:
                                        D(bug("activate sheep-net\n"));
                                        active = false;
                                        clear();
                                        active = true;
                                        goto next;

                                case DEACTIVATE_SHEEP_NET:
                                        D(bug("deactivate sheep-net\n"));
                                        active = false;
                                        clear();
                                        goto next;

                                case SHUTDOWN_SHEEP_NET:
                                        D(bug("shutdown sheep-net\n"));
                                        active = false;
                                        clear();
                                        shutdown_now = true;
                                        goto next;

                                case ADD_MULTICAST: {
                                        const char *data = (const char *)p->data;
                                        D(bug("add multicast %02x %02x %02x %02x %02x %02x\n", data[0], data[1], data[2], data[3], data[4], data[5]));
                                        if (active) {
                                                status_t result;
                                                if ((result = EtherCard->AddMulticastAddress(data)) != B_OK) {
                                                        // !! handle error !! error while creating multicast address
                                                        D(bug("error while creating multicast address %d\n", result));
                                                }
                                        }
                                        break;
                                }

                                case REMOVE_MULTICAST: {
                                        const char *data = (const char *)p->data;
                                        D(bug("remove multicast %02x %02x %02x %02x %02x %02x\n", data[0], data[1], data[2], data[3], data[4], data[5]));
                                        if (active) {
                                                status_t result;
                                                if ((result = EtherCard->RemoveMulticastAddress(data)) != B_OK) {
                                                        // !! handle error !! error while removing multicast address
                                                        D(bug("error while removing multicast address %d\n", result));
                                                }
                                        }
                                        break;
                                }

                                case SHEEP_PACKET: {
                                        uint32 length = p->length;
                                        // D(bug("sheep packet %d\n", length));
                                        if (active) {
                                                BStandardPacket *packet = new BStandardPacket(length);
                                                packet->Write(0, (const char *)p->data, length);
                                                EtherCard->SendPacket(packet);
                                        }
                                        break;
                                }

                                default:
                                        D(bug("error: unknown port packet type\n"));
                                        break;
                        }
                        p->cmd = 0;     // Free packet                                  
                        wr_pos = (wr_pos + 1) % WRITE_PACKET_COUNT;
                        p = &net_buffer_ptr->write[wr_pos];
                }

                // Wait for next packet
next:   acquire_sem_etc(write_sem, 1, B_TIMEOUT, 25000);
        }
        return 0;
}


/*
 *  Init the net add-on
 */

static void init_addon()
{
        int i;
        D(bug("init sheep-net\n"));

        // Create packet buffer
        if ((buffer_area = create_area("packet buffer", (void **)&net_buffer_ptr, B_ANY_ADDRESS, buffer_size, B_FULL_LOCK, B_READ_AREA | B_WRITE_AREA)) < B_NO_ERROR) {
                D(bug("FATAL ERROR: can't create shared area\n"));
                return;
        }       

        // Init packet buffer
        clear();
        EtherCard->Address((char *)net_buffer_ptr->ether_addr);
        net_buffer_ptr->read_sem = -1;
        net_buffer_ptr->read_ofs = (uint32)(net_buffer_ptr->read) - (uint32)net_buffer_ptr;
        net_buffer_ptr->read_packet_size = sizeof(net_packet);
        net_buffer_ptr->read_packet_count = READ_PACKET_COUNT;
        if ((write_sem = create_sem(0, "ether write")) < B_NO_ERROR) {
                D(bug("FATAL ERROR: can't create semaphore\n"));
                return;
        }
        net_buffer_ptr->write_sem = write_sem;
        net_buffer_ptr->write_ofs = (uint32)(net_buffer_ptr->write) - (uint32)net_buffer_ptr;
        net_buffer_ptr->write_packet_size = sizeof(net_packet);
        net_buffer_ptr->write_packet_count = WRITE_PACKET_COUNT;

        // Start packet writer thread
        write_thread = spawn_thread(write_packet_func, "sheep_net ether write", B_URGENT_DISPLAY_PRIORITY, NULL);
        resume_thread(write_thread);
}


/*
 *  Add-on attached to Ethernet card
 */

void SheepNetAddOn::AddDevice(BNetDevice *dev, const char *name)
{
        if (dev->Type() != B_ETHER_NET_DEVICE)
                return;
        if (EtherCard != NULL) {
                // !! handle error !! support for multiple ethernet cards ...
                D(bug("error: SheepShaver doesn't support multiple Ethernetcards !\n"));
                return;
        }
        EtherCard = dev;
        init_addon();
        register_packet_handler(this, dev, NETDUMP_PRIO);
}


/*
 *  Ethernet packet received
 */

bool SheepNetAddOn::PacketReceived(BNetPacket *pkt, BNetDevice *dev)
{
        if (shutdown_now) {
                unregister_packet_handler(this, dev);
                return false;
        }
//      D(bug("read_packet_func %d\n", pkt->Size()));
        if (active) {
                D(bug("rp: %d\n", rd_pos));
                net_packet *p = &net_buffer_ptr->read[rd_pos];
                if (p->cmd & IN_USE) {
                        D(bug("error: full read buffer ... lost packet\n"));
                } else {
                        memcpy(p->data, pkt->Data(), pkt->Size());
                        p->length = pkt->Size();
                        p->cmd = IN_USE | (SHEEP_PACKET << 8);
                        rd_pos = (rd_pos + 1) % READ_PACKET_COUNT;
                        release_sem(net_buffer_ptr->read_sem);
                }
        }
        //D(bug("%02x %02x %02x %02x %02x %02x", (uchar) (pkt->Data())[0],(uchar) (pkt->Data())[1],(uchar) (pkt->Data())[2],(uchar) (pkt->Data())[3],(uchar) (pkt->Data())[4],(uchar) (pkt->Data())[5]));
        return false;
}

#pragma export on
extern "C" BNetProtocol *open_protocol(const char *device)
{
        SheepNetAddOn *dev = new SheepNetAddOn;
        return dev;
}
#pragma export off
Revision:	1.4
Committed:	2002-01-15T14:58:36Z (22 years, 8 months ago) by cebix
Branch:	MAIN
CVS Tags:	nigel-build-19, nigel-build-12, nigel-build-13, nigel-build-16, nigel-build-17, nigel-build-15, snapshot-15012002
Changes since 1.3:	+2 -2 lines
Log Message:	- documentation updates - 2001 -> 2002 - version 0.9 -> 1.0
#	Content
1	/*
2	* sheep_net.cpp - Net server add-on for SheepShaver and Basilisk II
3	*
4	* SheepShaver (C) 1997-2002 Marc Hellwig and Christian Bauer
5	* Basilisk II (C) 1997-2002 Christian Bauer
6	*
7	* This program is free software; you can redistribute it and/or modify
8	* it under the terms of the GNU General Public License as published by
9	* the Free Software Foundation; either version 2 of the License, or
10	* (at your option) any later version.
11	*
12	* This program is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with this program; if not, write to the Free Software
19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20	*/
21
22	#include <KernelKit.h>
23	#include <SupportKit.h>
24	#include <add-ons/net_server/NetDevice.h>
25	#include <add-ons/net_server/NetProtocol.h>
26	#include <stdio.h>
27	#include <stdlib.h>
28	#include <stdarg.h>
29	#include <string.h>
30	#include <time.h>
31
32	#include "sheep_net.h"
33
34	#define DEBUG 0
35
36	#if DEBUG==1
37	#define bug pprintf
38	#elif DEBUG==2
39	#define bug kprintf
40	#endif
41
42	#if DEBUG
43	#define D(x) (x)
44	#else
45	#define D(x) ;
46	#endif
47
48	static int pprintf(const char* format, ...)
49	{
50	port_id PortNum;
51	int len,Ret;
52	char Buffer[1024];
53	va_list ap;
54
55	if ((PortNum = find_port("PortLogger")) == B_NAME_NOT_FOUND)
56	return(PortNum);
57	for (len=0; len<1024; len++)
58	Buffer[len]='\0';
59	va_start(ap, format);
60	vsprintf(Buffer, format, ap);
61	Ret = write_port(PortNum, 0, Buffer, strlen(Buffer));
62	return(Ret);
63	}
64
65
66	// Constants
67	#define NETDUMP_PRIO 1 // Default is 0
68
69	const uint32 buffer_size = (sizeof(net_buffer) / B_PAGE_SIZE + 1) * B_PAGE_SIZE;
70
71
72	// SheepNet add-on object
73	class SheepNetAddOn : public BNetProtocol, BPacketHandler {
74	public:
75	void AddDevice(BNetDevice dev, const char name);
76	bool PacketReceived(BNetPacket buf, BNetDevice dev);
77	};
78
79
80	// Global variables
81	static bool shutdown_now = false;
82	static bool active = false;
83
84	static thread_id write_thread; // Packet writer
85	static sem_id write_sem; // Semaphore to trigger packet writing
86	static BNetDevice *EtherCard = NULL; // The Ethernet card we are attached to
87	static area_id buffer_area; // Packet buffer area
88	static net_buffer *net_buffer_ptr; // Pointer to packet buffer
89
90	static uint32 rd_pos; // Current read position in packet buffer
91	static uint32 wr_pos; // Current write position in packet buffer
92
93
94	/*
95	* Clear packet buffer
96	*/
97
98	static void clear(void)
99	{
100	int i;
101	for (i=0;i<READ_PACKET_COUNT;i++) {
102	net_buffer_ptr->read[i].cmd = 0;
103	net_buffer_ptr->read[i].length = 0;
104	net_buffer_ptr->read[i].card = 0;
105	net_buffer_ptr->read[i].reserved = 0;
106	}
107	for (i=0;i<WRITE_PACKET_COUNT;i++) {
108	net_buffer_ptr->write[i].cmd = 0;
109	net_buffer_ptr->write[i].length = 0;
110	net_buffer_ptr->write[i].card = 0;
111	net_buffer_ptr->write[i].reserved = 0;
112	}
113	rd_pos = wr_pos = 0;
114	}
115
116
117	/*
118	* Packet writer thread
119	*/
120
121	static status_t write_packet_func(void *arg)
122	{
123	while (!shutdown_now) {
124
125	// Read and execute command
126	net_packet *p = &net_buffer_ptr->write[wr_pos];
127	while (p->cmd & IN_USE) {
128	D(bug("wp: %d\n", wr_pos));
129	switch (p->cmd >> 8) {
130
131	case ACTIVATE_SHEEP_NET:
132	D(bug("activate sheep-net\n"));
133	active = false;
134	clear();
135	active = true;
136	goto next;
137
138	case DEACTIVATE_SHEEP_NET:
139	D(bug("deactivate sheep-net\n"));
140	active = false;
141	clear();
142	goto next;
143
144	case SHUTDOWN_SHEEP_NET:
145	D(bug("shutdown sheep-net\n"));
146	active = false;
147	clear();
148	shutdown_now = true;
149	goto next;
150
151	case ADD_MULTICAST: {
152	const char data = (const char )p->data;
153	D(bug("add multicast %02x %02x %02x %02x %02x %02x\n", data[0], data[1], data[2], data[3], data[4], data[5]));
154	if (active) {
155	status_t result;
156	if ((result = EtherCard->AddMulticastAddress(data)) != B_OK) {
157	// !! handle error !! error while creating multicast address
158	D(bug("error while creating multicast address %d\n", result));
159	}
160	}
161	break;
162	}
163
164	case REMOVE_MULTICAST: {
165	const char data = (const char )p->data;
166	D(bug("remove multicast %02x %02x %02x %02x %02x %02x\n", data[0], data[1], data[2], data[3], data[4], data[5]));
167	if (active) {
168	status_t result;
169	if ((result = EtherCard->RemoveMulticastAddress(data)) != B_OK) {
170	// !! handle error !! error while removing multicast address
171	D(bug("error while removing multicast address %d\n", result));
172	}
173	}
174	break;
175	}
176
177	case SHEEP_PACKET: {
178	uint32 length = p->length;
179	// D(bug("sheep packet %d\n", length));
180	if (active) {
181	BStandardPacket *packet = new BStandardPacket(length);
182	packet->Write(0, (const char *)p->data, length);
183	EtherCard->SendPacket(packet);
184	}
185	break;
186	}
187
188	default:
189	D(bug("error: unknown port packet type\n"));
190	break;
191	}
192	p->cmd = 0; // Free packet
193	wr_pos = (wr_pos + 1) % WRITE_PACKET_COUNT;
194	p = &net_buffer_ptr->write[wr_pos];
195	}
196
197	// Wait for next packet
198	next: acquire_sem_etc(write_sem, 1, B_TIMEOUT, 25000);
199	}
200	return 0;
201	}
202
203
204	/*
205	* Init the net add-on
206	*/
207
208	static void init_addon()
209	{
210	int i;
211	D(bug("init sheep-net\n"));
212
213	// Create packet buffer
214	if ((buffer_area = create_area("packet buffer", (void **)&net_buffer_ptr, B_ANY_ADDRESS, buffer_size, B_FULL_LOCK, B_READ_AREA \| B_WRITE_AREA)) < B_NO_ERROR) {
215	D(bug("FATAL ERROR: can't create shared area\n"));
216	return;
217	}
218
219	// Init packet buffer
220	clear();
221	EtherCard->Address((char *)net_buffer_ptr->ether_addr);
222	net_buffer_ptr->read_sem = -1;
223	net_buffer_ptr->read_ofs = (uint32)(net_buffer_ptr->read) - (uint32)net_buffer_ptr;
224	net_buffer_ptr->read_packet_size = sizeof(net_packet);
225	net_buffer_ptr->read_packet_count = READ_PACKET_COUNT;
226	if ((write_sem = create_sem(0, "ether write")) < B_NO_ERROR) {
227	D(bug("FATAL ERROR: can't create semaphore\n"));
228	return;
229	}
230	net_buffer_ptr->write_sem = write_sem;
231	net_buffer_ptr->write_ofs = (uint32)(net_buffer_ptr->write) - (uint32)net_buffer_ptr;
232	net_buffer_ptr->write_packet_size = sizeof(net_packet);
233	net_buffer_ptr->write_packet_count = WRITE_PACKET_COUNT;
234
235	// Start packet writer thread
236	write_thread = spawn_thread(write_packet_func, "sheep_net ether write", B_URGENT_DISPLAY_PRIORITY, NULL);
237	resume_thread(write_thread);
238	}
239
240
241	/*
242	* Add-on attached to Ethernet card
243	*/
244
245	void SheepNetAddOn::AddDevice(BNetDevice dev, const char name)
246	{
247	if (dev->Type() != B_ETHER_NET_DEVICE)
248	return;
249	if (EtherCard != NULL) {
250	// !! handle error !! support for multiple ethernet cards ...
251	D(bug("error: SheepShaver doesn't support multiple Ethernetcards !\n"));
252	return;
253	}
254	EtherCard = dev;
255	init_addon();
256	register_packet_handler(this, dev, NETDUMP_PRIO);
257	}
258
259
260	/*
261	* Ethernet packet received
262	*/
263
264	bool SheepNetAddOn::PacketReceived(BNetPacket pkt, BNetDevice dev)
265	{
266	if (shutdown_now) {
267	unregister_packet_handler(this, dev);
268	return false;
269	}
270	// D(bug("read_packet_func %d\n", pkt->Size()));
271	if (active) {
272	D(bug("rp: %d\n", rd_pos));
273	net_packet *p = &net_buffer_ptr->read[rd_pos];
274	if (p->cmd & IN_USE) {
275	D(bug("error: full read buffer ... lost packet\n"));
276	} else {
277	memcpy(p->data, pkt->Data(), pkt->Size());
278	p->length = pkt->Size();
279	p->cmd = IN_USE \| (SHEEP_PACKET << 8);
280	rd_pos = (rd_pos + 1) % READ_PACKET_COUNT;
281	release_sem(net_buffer_ptr->read_sem);
282	}
283	}
284	//D(bug("%02x %02x %02x %02x %02x %02x", (uchar) (pkt->Data())[0],(uchar) (pkt->Data())[1],(uchar) (pkt->Data())[2],(uchar) (pkt->Data())[3],(uchar) (pkt->Data())[4],(uchar) (pkt->Data())[5]));
285	return false;
286	}
287
288	#pragma export on
289	extern "C" BNetProtocol open_protocol(const char device)
290	{
291	SheepNetAddOn *dev = new SheepNetAddOn;
292	return dev;
293	}
294	#pragma export off