Macintosh-Tools
/
macemu
mirror of https://github.com/kanjitalk755/macemu.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
macemu/SheepShaver/src/ether.cpp

1633 lines
45 KiB
C++
Raw Blame History

/*
* ether.cpp - SheepShaver Ethernet Device Driver (DLPI)
*
* SheepShaver (C) 1997-2002 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
*/
/*
* TODO
* - 802.2 TEST/XID
* - MIB statistics
*/
#include <string.h>
#include "sysdeps.h"
#include "ether.h"
#include "ether_defs.h"
#include "macos_util.h"
#include "cpu_emulation.h"
#include "emul_op.h"
#include "main.h"
#define DEBUG 0
#include "debug.h"
// Packet types
enum {
kPktDIX = 0,
kPkt8022SAP = 1,
kPkt8022GroupSAP = 2,
kPkt8022SNAP = 3,
kPktIPX = 4,
kPktUnknown = 5
};
/*
* Stream private data structure
*/
static const int kGroupSAPMapSize = 128/32; // Number of 32-bit values we need for 128 bits
static const int kGSshift = 6;
static const int kGSmask = 0x1F;
struct multicast_node {
multicast_node *next;
uint8 addr[kEnetPhysicalAddressLength];
};
struct DLPIStream {
void SetGroupSAP(uint8 sap)
{
group_sap[sap >> kGSshift] |= (1L << ((sap >> 1) & kGSmask));
}
void ClearGroupSAP(uint8 sap)
{
group_sap[sap >> kGSshift] &= ~(1L << ((sap >> 1) & kGSmask));
}
void ClearAllGroupSAPs(void)
{
for (int i=0; i<kGroupSAPMapSize; i++)
group_sap[i] = 0;
}
bool TestGroupSAP(uint8 sap)
{
return group_sap[sap >> kGSshift] & (1L << ((sap >> 1) & kGSmask));
}
void AddMulticast(uint8 *addr)
{
multicast_node *n = new multicast_node;
memcpy(n->addr, addr, kEnetPhysicalAddressLength);
n->next = multicast_list;
multicast_list = n;
}
void RemoveMulticast(uint8 *addr)
{
multicast_node *p = multicast_list;
while (p) {
if (memcmp(addr, p->addr, kEnetPhysicalAddressLength) == 0)
goto found;
p = p->next;
}
return;
found:
multicast_node *q = (multicast_node *)&multicast_list;
while (q) {
if (q->next == p) {
q->next = p->next;
delete p;
return;
}
q = q->next;
}
}
uint8 *IsMulticastRegistered(uint8 *addr)
{
multicast_node *n = multicast_list;
while (n) {
if (memcmp(addr, n->addr, kEnetPhysicalAddressLength) == 0)
return n->addr;
n = n->next;
}
return NULL;
}
uint32 minor_num; // Minor device number of this stream
uint32 dlpi_state; // DLPI state of this stream
uint32 flags; // Flags
uint16 dlsap; // SAP bound to this stream
bool framing_8022; // Using 802.2 framing? This is only used to report the MAC type for DL_INFO_ACK and can be set with an ioctl() call
queue_t *rdq; // Read queue for this stream
uint32 group_sap[kGroupSAPMapSize]; // Map of bound group SAPs
uint8 snap[k8022SNAPLength]; // SNAP bound to this stream
multicast_node *multicast_list; // List of enabled multicast addresses
};
// Stream flags
enum {
kSnapStream = 0x00000001,
kAcceptMulticasts = 0x00000002,
kAcceptAll8022Packets = 0x00000004,
kFastPathMode = 0x00000008
};
// List of opened streams (used internally by OpenTransport)
static DLPIStream *dlpi_stream_list = NULL;
// Are we open?
bool ether_driver_opened = false;
// Our ethernet hardware address
static uint8 hardware_address[6] = {0, 0, 0, 0, 0, 0};
// Statistics
int32 num_wput = 0;
int32 num_error_acks = 0;
int32 num_tx_packets = 0;
int32 num_tx_raw_packets = 0;
int32 num_tx_normal_packets = 0;
int32 num_tx_buffer_full = 0;
int32 num_rx_packets = 0;
int32 num_ether_irq = 0;
int32 num_unitdata_ind = 0;
int32 num_rx_fastpath = 0;
int32 num_rx_no_mem = 0;
int32 num_rx_dropped = 0;
int32 num_rx_stream_not_ready = 0;
int32 num_rx_no_unitdata_mem = 0;
// Function pointers of imported functions
typedef mblk_t *(*allocb_ptr)(size_t size, int pri);
static uint32 allocb_tvect = 0;
mblk_t *allocb(size_t arg1, int arg2)
{
return (mblk_t *)CallMacOS2(allocb_ptr, allocb_tvect, arg1, arg2);
}
typedef void (*freeb_ptr)(mblk_t *);
static uint32 freeb_tvect = 0;
static inline void freeb(mblk_t *arg1)
{
CallMacOS1(freeb_ptr, freeb_tvect, arg1);
}
typedef int16 (*freemsg_ptr)(mblk_t *);
static uint32 freemsg_tvect = 0;
static inline int16 freemsg(mblk_t *arg1)
{
return (int16)CallMacOS1(freemsg_ptr, freemsg_tvect, arg1);
}
typedef mblk_t *(*copyb_ptr)(mblk_t *);
static uint32 copyb_tvect = 0;
static inline mblk_t *copyb(mblk_t *arg1)
{
return (mblk_t *)CallMacOS1(copyb_ptr, copyb_tvect, arg1);
}
typedef mblk_t *(*dupmsg_ptr)(mblk_t *);
static uint32 dupmsg_tvect = 0;
static inline mblk_t *dupmsg(mblk_t *arg1)
{
return (mblk_t *)CallMacOS1(dupmsg_ptr, dupmsg_tvect, arg1);
}
typedef mblk_t *(*getq_ptr)(queue_t *);
static uint32 getq_tvect = 0;
static inline mblk_t *getq(queue_t *arg1)
{
return (mblk_t *)CallMacOS1(getq_ptr, getq_tvect, arg1);
}
typedef int (*putq_ptr)(queue_t *, mblk_t *);
static uint32 putq_tvect = 0;
static inline int putq(queue_t *arg1, mblk_t *arg2)
{
return (int)CallMacOS2(putq_ptr, putq_tvect, arg1, arg2);
}
typedef int (*putnext_ptr)(queue_t *, mblk_t *);
static uint32 putnext_tvect = 0;
static inline int putnext(queue_t *arg1, mblk_t *arg2)
{
return (int)CallMacOS2(putnext_ptr, putnext_tvect, arg1, arg2);
}
typedef int (*putnextctl1_ptr)(queue_t *, int type, int c);
static uint32 putnextctl1_tvect = 0;
static inline int putnextctl1(queue_t *arg1, int arg2, int arg3)
{
return (int)CallMacOS3(putnextctl1_ptr, putnextctl1_tvect, arg1, arg2, arg3);
}
typedef int (*canputnext_ptr)(queue_t *);
static uint32 canputnext_tvect = 0;
static inline int canputnext(queue_t *arg1)
{
return (int)CallMacOS1(canputnext_ptr, canputnext_tvect, arg1);
}
typedef int (*qreply_ptr)(queue_t *, mblk_t *);
static uint32 qreply_tvect = 0;
static inline int qreply(queue_t *arg1, mblk_t *arg2)
{
return (int)CallMacOS2(qreply_ptr, qreply_tvect, arg1, arg2);
}
typedef void (*flushq_ptr)(queue_t *, int flag);
static uint32 flushq_tvect = 0;
static inline void flushq(queue_t *arg1, int arg2)
{
CallMacOS2(flushq_ptr, flushq_tvect, arg1, arg2);
}
typedef int (*msgdsize_ptr)(const mblk_t *);
static uint32 msgdsize_tvect = 0;
static inline int msgdsize(const mblk_t *arg1)
{
return (int)CallMacOS1(msgdsize_ptr, msgdsize_tvect, arg1);
}
typedef void (*otenterint_ptr)(void);
static uint32 otenterint_tvect = 0;
void OTEnterInterrupt(void)
{
CallMacOS(otenterint_ptr, otenterint_tvect);
}
typedef void (*otleaveint_ptr)(void);
static uint32 otleaveint_tvect = 0;
void OTLeaveInterrupt(void)
{
CallMacOS(otleaveint_ptr, otleaveint_tvect);
}
typedef int (*mi_open_comm_ptr)(DLPIStream **mi_opp_orig, size_t size, queue_t *q, void *dev, int flag, int sflag, void *credp);
static uint32 mi_open_comm_tvect = 0;
static inline int mi_open_comm(DLPIStream **arg1, size_t arg2, queue_t *arg3, void *arg4, int arg5, int arg6, void *arg7)
{
return (int)CallMacOS7(mi_open_comm_ptr, mi_open_comm_tvect, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
}
typedef int (*mi_close_comm_ptr)(DLPIStream **mi_opp_orig, queue_t *q);
static uint32 mi_close_comm_tvect = 0;
static inline int mi_close_comm(DLPIStream **arg1, queue_t *arg2)
{
return (int)CallMacOS2(mi_close_comm_ptr, mi_close_comm_tvect, arg1, arg2);
}
typedef DLPIStream *(*mi_next_ptr_ptr)(DLPIStream *);
static uint32 mi_next_ptr_tvect = 0;
static inline DLPIStream *mi_next_ptr(DLPIStream *arg1)
{
return (DLPIStream *)CallMacOS1(mi_next_ptr_ptr, mi_next_ptr_tvect, arg1);
}
// Prototypes
static void ether_ioctl(DLPIStream *the_stream, queue_t* q, mblk_t* mp);
static void ether_flush(queue_t* q, mblk_t* mp);
static mblk_t *build_tx_packet_header(DLPIStream *the_stream, mblk_t *mp, bool fast_path);
static void transmit_packet(mblk_t *mp);
static void DLPI_error_ack(DLPIStream *the_stream, queue_t *q, mblk_t *ack_mp, uint32 prim, uint32 err, uint32 uerr);
static void DLPI_ok_ack(DLPIStream *the_stream, queue_t *q, mblk_t *ack_mp, uint32 prim);
static void DLPI_info(DLPIStream *the_stream, queue_t *q, mblk_t *mp);
static void DLPI_phys_addr(DLPIStream *the_stream, queue_t *q, mblk_t *mp);
static void DLPI_bind(DLPIStream *the_stream, queue_t *q, mblk_t *mp);
static void DLPI_unbind(DLPIStream *the_stream, queue_t *q, mblk_t *mp);
static void DLPI_subs_bind(DLPIStream *the_stream, queue_t *q, mblk_t *mp);
static void DLPI_subs_unbind(DLPIStream *the_stream, queue_t *q, mblk_t *mp);
static void DLPI_enable_multi(DLPIStream *the_stream, queue_t *q, mblk_t *mp);
static void DLPI_disable_multi(DLPIStream *the_stream, queue_t *q, mblk_t *mp);
static void DLPI_unit_data(DLPIStream *the_stream, queue_t *q, mblk_t *mp);
/*
* Initialize ethernet stream module
*/
uint8 InitStreamModule(void *theID)
{
D(bug("InitStreamModule\n"));
// Don't re-open if already open
if (ether_driver_opened)
return true;
ether_driver_opened = false;
// Import functions from OTKernelLib
allocb_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\006allocb");
D(bug("allocb TVECT at %08lx\n", allocb_tvect));
if (allocb_tvect == 0)
return false;
freeb_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\005freeb");
D(bug("freeb TVECT at %08lx\n", freeb_tvect));
if (freeb_tvect == 0)
return false;
freemsg_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\007freemsg");
D(bug("freemsg TVECT at %08lx\n", freemsg_tvect));
if (freemsg_tvect == 0)
return false;
copyb_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\005copyb");
D(bug("copyb TVECT at %08lx\n", copyb_tvect));
if (copyb_tvect == 0)
return false;
dupmsg_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\006dupmsg");
D(bug("dupmsg TVECT at %08lx\n", dupmsg_tvect));
if (dupmsg_tvect == 0)
return false;
getq_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\004getq");
D(bug("getq TVECT at %08lx\n", getq_tvect));
if (getq_tvect == 0)
return false;
putq_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\004putq");
D(bug("putq TVECT at %08lx\n", putq_tvect));
if (putq_tvect == 0)
return false;
putnext_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\007putnext");
D(bug("putnext TVECT at %08lx\n", putnext_tvect));
if (putnext_tvect == 0)
return false;
putnextctl1_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\013putnextctl1");
D(bug("putnextctl1 TVECT at %08lx\n", putnextctl1_tvect));
if (putnextctl1_tvect == 0)
return false;
canputnext_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\012canputnext");
D(bug("canputnext TVECT at %08lx\n", canputnext_tvect));
if (canputnext_tvect == 0)
return false;
qreply_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\006qreply");
D(bug("qreply TVECT at %08lx\n", qreply_tvect));
if (qreply_tvect == 0)
return false;
flushq_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\006flushq");
D(bug("flushq TVECT at %08lx\n", flushq_tvect));
if (flushq_tvect == 0)
return false;
msgdsize_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\010msgdsize");
D(bug("msgdsize TVECT at %08lx\n", msgdsize_tvect));
if (msgdsize_tvect == 0)
return false;
otenterint_tvect = (uint32)FindLibSymbol("\017OTKernelUtilLib", "\020OTEnterInterrupt");
D(bug("OTEnterInterrupt TVECT at %08lx\n", otenterint_tvect));
if (otenterint_tvect == 0)
return false;
otleaveint_tvect = (uint32)FindLibSymbol("\017OTKernelUtilLib", "\020OTLeaveInterrupt");
D(bug("OTLeaveInterrupt TVECT at %08lx\n", otleaveint_tvect));
if (otleaveint_tvect == 0)
return false;
mi_open_comm_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\014mi_open_comm");
D(bug("mi_open_comm TVECT at %08lx\n", mi_open_comm_tvect));
if (mi_open_comm_tvect == 0)
return false;
mi_close_comm_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\015mi_close_comm");
D(bug("mi_close_comm TVECT at %08lx\n", mi_close_comm_tvect));
if (mi_close_comm_tvect == 0)
return false;
mi_next_ptr_tvect = (uint32)FindLibSymbol("\013OTKernelLib", "\013mi_next_ptr");
D(bug("mi_next_ptr TVECT at %08lx\n", mi_next_ptr_tvect));
if (mi_next_ptr_tvect == 0)
return false;
// Initialize stream list (which might be leftover)
dlpi_stream_list = NULL;
// Ask add-on for ethernet hardware address
AO_get_ethernet_address(hardware_address);
// Yes, we're open
ether_driver_opened = true;
return true;
}
/*
* Terminate ethernet stream module
*/
void TerminateStreamModule(void)
{
D(bug("TerminateStreamModule\n"));
// This happens sometimes. I don't know why.
if (dlpi_stream_list != NULL)
printf("FATAL: TerminateStreamModule() called, but streams still open\n");
// Sorry, we're closed
ether_driver_opened = false;
}
/*
* Open new stream
*/
int ether_open(queue_t *rdq, void *dev, int flag, int sflag, void *creds)
{
D(bug("ether_open(%p,%p,%d,%d,%p)\n", rdq, dev, flag, sflag, creds));
// Return if driver was closed
if (!ether_driver_opened) {
printf("FATAL: ether_open(): Ethernet driver not opened\n");
return MAC_ENXIO;
}
// If we're being reopened, just return
if (rdq->q_ptr != NULL)
return 0;
// Allocate DLPIStream structure
int err = mi_open_comm(&dlpi_stream_list, sizeof(DLPIStream), rdq, dev, flag, sflag, creds);
if (err)
return err;
DLPIStream *the_stream = (DLPIStream *)rdq->q_ptr;
the_stream->rdq = rdq;
the_stream->dlpi_state = DL_UNBOUND;
the_stream->flags = 0;
the_stream->dlsap = 0;
the_stream->framing_8022 = false;
the_stream->multicast_list = NULL;
return 0;
}
/*
* Close stream
*/
int ether_close(queue_t *rdq, int flag, void *creds)
{
D(bug("ether_close(%p,%d,%p)\n", rdq, flag, creds));
// Return if driver was closed
if (!ether_driver_opened) {
printf("FATAL: ether_close(): Ethernet driver not opened\n");
return MAC_ENXIO;
}
// Get stream
DLPIStream *the_stream = (DLPIStream *)rdq->q_ptr;
// Don't close if never opened
if (the_stream == NULL)
return 0;
// Disable all registered multicast addresses
while (the_stream->multicast_list) {
AO_disable_multicast(the_stream->multicast_list->addr);
the_stream->RemoveMulticast(the_stream->multicast_list->addr);
}
the_stream->multicast_list = NULL;
// Delete the DLPIStream
return mi_close_comm(&dlpi_stream_list, rdq);
}
/*
* Put something on the write queue
*/
int ether_wput(queue_t *q, mblk_t *mp)
{
D(bug("ether_wput(%p,%p)\n", q, mp));
// Return if driver was closed
if (!ether_driver_opened) {
printf("FATAL: ether_wput(): Ethernet driver not opened\n");
return MAC_ENXIO;
}
// Get stream
DLPIStream *the_stream = (DLPIStream *)q->q_ptr;
if (the_stream == NULL)
return MAC_ENXIO;
D(bug(" db_type %d\n", mp->b_datap->db_type));
switch (mp->b_datap->db_type) {
case M_DATA:
// Transmit raw packet
D(bug(" raw packet\n"));
num_tx_raw_packets++;
transmit_packet(mp);
break;
case M_PROTO:
case M_PCPROTO: {
union DL_primitives *dlp = (union DL_primitives *)mp->b_rptr;
uint32 prim = dlp->dl_primitive;
D(bug(" dl_primitive %d\n", prim));
switch (prim) {
case DL_UNITDATA_REQ:
// Transmit normal packet
num_tx_normal_packets++;
DLPI_unit_data(the_stream, q, mp);
break;
case DL_INFO_REQ:
DLPI_info(the_stream, q, mp);
break;
case DL_PHYS_ADDR_REQ:
DLPI_phys_addr(the_stream, q, mp);
break;
case DL_BIND_REQ:
DLPI_bind(the_stream, q, mp);
break;
case DL_UNBIND_REQ:
DLPI_unbind(the_stream, q, mp);
break;
case DL_SUBS_BIND_REQ:
DLPI_subs_bind(the_stream, q, mp);
break;
case DL_SUBS_UNBIND_REQ:
DLPI_subs_unbind(the_stream, q, mp);
break;
case DL_ENABMULTI_REQ:
DLPI_enable_multi(the_stream, q, mp);
break;
case DL_DISABMULTI_REQ:
DLPI_disable_multi(the_stream, q, mp);
break;
default:
D(bug("WARNING: ether_wsrv(): Unknown primitive\n"));
DLPI_error_ack(the_stream, q, mp, prim, DL_NOTSUPPORTED, 0);
break;
}
break;
}
case M_IOCTL:
ether_ioctl(the_stream, q, mp);
break;
case M_FLUSH:
ether_flush(q, mp);
break;
default:
D(bug("WARNING: ether_wput(): Unknown message type\n"));
freemsg(mp);
break;
}
num_wput++;
return 0;
}
/*
* Dequeue and process messages from the read queue
*/
int ether_rsrv(queue_t *q)
{
mblk_t *mp;
while ((mp = getq(q)) != NULL) {
if (canputnext(q))
putnext(q, mp);
else {
freemsg(mp);
flushq(q, FLUSHDATA);
break;
}
}
return 0;
}
/*
* Handle ioctl calls
*/
static void ether_ioctl(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
{
struct iocblk *ioc = (struct iocblk *)mp->b_rptr;
D(bug(" ether_ioctl(%p,%p) cmd %d\n", q, mp, ioc->ioc_cmd));
switch (ioc->ioc_cmd) {
case I_OTSetFramingType: { // Toggles what the general info primitive returns for dl_mac_type in dl_info_ack_t structure
mblk_t *info_mp = mp->b_cont;
if (info_mp == NULL || ((info_mp->b_wptr - info_mp->b_rptr) != sizeof(uint32))) {
ioc->ioc_error = MAC_EINVAL;
goto ioctl_error;
}
uint32 framing_type = *(uint32 *)info_mp->b_rptr;
D(bug(" I_OTSetFramingType type %d\n", framing_type));
if (framing_type != kOTGetFramingValue)
the_stream->framing_8022 = (framing_type == kOTFraming8022);
mp->b_cont = NULL;
freemsg(info_mp);
if (the_stream->framing_8022)
ioc->ioc_rval = kOTFraming8022;
else
ioc->ioc_rval = kOTFramingEthernet;
goto ioctl_ok;
}
case DL_IOC_HDR_INFO: { // Special Mentat call, for fast transmits
D(bug(" DL_IOC_HDR_INFO\n"));
mblk_t *info_mp = mp->b_cont;
// Copy DL_UNITDATA_REQ block
mblk_t *unitdata_mp = copyb(info_mp);
if (unitdata_mp == NULL) {
ioc->ioc_error = MAC_ENOMEM;
goto ioctl_error;
}
unitdata_mp->b_datap->db_type = M_PROTO;
// Construct header (converts DL_UNITDATA_REQ -> M_DATA)
mblk_t *header_mp = build_tx_packet_header(the_stream, unitdata_mp, true);
if (header_mp == NULL) {
// Could not allocate a message block large enough
ioc->ioc_error = MAC_ENOMEM;
goto ioctl_error;
}
// Attach header block at the end
mp->b_cont->b_cont = header_mp;
the_stream->flags |= kFastPathMode;
goto ioctl_ok;
}
case I_OTSetRawMode: {
mblk_t *info_mp = mp->b_cont;
dl_recv_control_t *dlrc;
if (info_mp == NULL || ((info_mp->b_wptr - info_mp->b_rptr) != sizeof(dlrc->dl_primitive))) {
ioc->ioc_error = MAC_EINVAL;
goto ioctl_error;
}
dlrc = (dl_recv_control_t *)info_mp->b_rptr;
D(bug(" I_OTSetRawMode primitive %d\n", dlrc->dl_primitive));
ioc->ioc_error = MAC_EINVAL;
goto ioctl_error;
}
default:
D(bug("WARNING: Unknown ether_ioctl() call\n"));
ioc->ioc_error = MAC_EINVAL;
goto ioctl_error;
}
ioctl_ok:
ioc->ioc_count = 0;
for (mblk_t *mp1 = mp; (mp1 = mp1->b_cont) != NULL;)
ioc->ioc_count += mp1->b_wptr - mp1->b_rptr;
ioc->ioc_error = 0;
mp->b_datap->db_type = M_IOCACK;
qreply(q, mp);
return;
ioctl_error:
mp->b_datap->db_type = M_IOCNAK;
qreply(q, mp);
return;
}
/*
* Flush call, send it up to the read side of the stream
*/
static void ether_flush(queue_t* q, mblk_t* mp)
{
D(bug(" ether_flush(%p,%p)\n", q, mp));
uint8 *rptr = mp->b_rptr;
if (*rptr & FLUSHW)
flushq(q, FLUSHALL);
if (*rptr & FLUSHR) {
flushq(RD(q), FLUSHALL);
*rptr &= ~FLUSHW;
qreply(q, mp);
} else
freemsg(mp);
}
/*
* Classify packet into the different types of protocols
*/
static uint16 classify_packet_type(uint16 primarySAP, uint16 secondarySAP)
{
if (primarySAP >= kMinDIXSAP)
return kPktDIX;
if ((primarySAP == kIPXSAP) && (secondarySAP == kIPXSAP))
return kPktIPX;
if (primarySAP == kSNAPSAP)
return kPkt8022SNAP;
if (primarySAP <= k8022GlobalSAP)
return kPkt8022SAP;
return kPktUnknown;
}
/*
* Check if the address is a multicast, broadcast or standard address
*/
static int32 get_address_type(uint8 *addr)
{
if (addr[0] & 1) { // Multicast/broadcast flag
if (OTIs48BitBroadcastAddress(addr))
return keaBroadcast;
else
return keaMulticast;
} else
return keaStandardAddress;
}
/*
* Reuse a message block, make room for more data
*/
static mblk_t *reuse_message_block(mblk_t *mp, uint16 needed_size)
{
mblk_t *nmp;
if ((mp->b_datap->db_ref == 1) && ((mp->b_datap->db_lim - mp->b_datap->db_base) >= needed_size)) {
mp->b_datap->db_type = M_DATA;
mp->b_rptr = mp->b_datap->db_base;
mp->b_wptr = mp->b_datap->db_base + needed_size;
} else {
nmp = mp->b_cont; // Grab the M_DATA blocks
mp->b_cont = NULL; // Detach the M_(PC)PROTO
freemsg(mp); // Free the M_(PC)PROTO
mp = nmp; // Point to the M_DATA blocks
// Try to get space on the first M_DATA block
if (mp && (mp->b_datap->db_ref == 1) && ((mp->b_rptr - mp->b_datap->db_base) >= needed_size))
mp->b_rptr -= needed_size;
else {
// Try to allocate a new message
if ((nmp = allocb(needed_size, BPRI_HI)) == NULL) {
// Could not get a new message block so lets forget about the message altogether
freemsg(mp); // Free the original M_DATA portion of the message
mp = NULL; // Indicates the reuse failed
} else {
nmp->b_cont = mp; // Attach the new message block as the head
nmp->b_wptr += needed_size;
mp = nmp;
}
}
}
return mp;
}
/*
* Built header for packet to be transmitted (convert DL_UNITDATA_REQ -> M_DATA)
* The passed-in message has the header info in the first message block and the data
* in the following blocks
*/
static mblk_t *build_tx_packet_header(DLPIStream *the_stream, mblk_t *mp, bool fast_path)
{
// Only handle unit_data requests
dl_unitdata_req_t *req = (dl_unitdata_req_t *)mp->b_rptr;
if (req->dl_primitive != DL_UNITDATA_REQ) {
freemsg(mp);
return NULL;
}
// Extract destination address and its length
uint8 *destAddrOrig = ((uint8 *)req) + req->dl_dest_addr_offset;
uint32 destAddrLen = req->dl_dest_addr_length;
uint8 ctrl = 0x03;
// Extract DLSAP
uint16 dlsap;
switch (destAddrLen) {
case kEnetPhysicalAddressLength:
dlsap = the_stream->dlsap;
break;
case kEnetAndSAPAddressLength:
dlsap = *(uint16 *)(destAddrOrig + kEnetPhysicalAddressLength);
break;
case kEnetPhysicalAddressLength + k8022DLSAPLength + k8022SNAPLength: // SNAP SAP
dlsap = *(uint16 *)(destAddrOrig + kEnetPhysicalAddressLength);
break;
default:
dlsap = the_stream->dlsap;
break;
}
// Extract data size (excluding header info) and packet type
uint16 datasize = msgdsize(mp);
uint16 packetType = classify_packet_type(the_stream->dlsap, dlsap);
// Calculate header size and protocol type/size field
uint16 hdrsize, proto;
switch (packetType) {
case kPktDIX:
hdrsize = kEnetPacketHeaderLength;
proto = dlsap;
break;
case kPkt8022SAP:
hdrsize = kEnetPacketHeaderLength + k8022BasicHeaderLength;
if (fast_path)
proto = 0;
else
proto = datasize + k8022BasicHeaderLength;
break;
case kPkt8022SNAP:
hdrsize = kEnetPacketHeaderLength + k8022SNAPHeaderLength;
if (fast_path)
proto = 0;
else
proto = datasize + k8022SNAPHeaderLength;
break;
case kPktIPX:
hdrsize = kEnetPacketHeaderLength;
if (fast_path)
proto = 0;
else
proto = datasize;
break;
default:
hdrsize = kEnetPacketHeaderLength;
proto = dlsap;
break;
}
// We need to copy the dest address info in the message before we can reuse it
uint8 destAddrCopy[kMaxBoundAddrLength];
memcpy(destAddrCopy, destAddrOrig, destAddrLen);
// Resize header info in message block
if ((mp = reuse_message_block(mp, hdrsize)) == NULL)
return NULL;
struct T8022FullPacketHeader *packetHeader = (struct T8022FullPacketHeader *)mp->b_rptr;
// Set protocol type/size field
packetHeader->fEnetPart.fProto = proto;
// Set destination ethernet address
OTCopy48BitAddress(destAddrCopy, packetHeader->fEnetPart.fDestAddr);
// Set other header fields
switch (packetType) {
case kPkt8022SAP:
packetHeader->f8022Part.fDSAP = (uint8)dlsap;
packetHeader->f8022Part.fSSAP = (uint8)the_stream->dlsap;
packetHeader->f8022Part.fCtrl = ctrl;
break;
case kPkt8022SNAP: {
uint8 *snapStart;
packetHeader->f8022Part.fDSAP = (uint8)dlsap;
packetHeader->f8022Part.fSSAP = (uint8)the_stream->dlsap;
packetHeader->f8022Part.fCtrl = ctrl;
if (destAddrLen >= kEnetAndSAPAddressLength + k8022SNAPLength)
snapStart = destAddrCopy + kEnetAndSAPAddressLength;
else
snapStart = the_stream->snap;
OTCopy8022SNAP(snapStart, packetHeader->f8022Part.fSNAP);
break;
}
}
// Return updated message
return mp;
}
/*
* Transmit packet
*/
static void transmit_packet(mblk_t *mp)
{
EnetPacketHeader *enetHeader = (EnetPacketHeader *)mp->b_rptr;
// Fill in length in 802.3 packets
if (enetHeader->fProto == 0)
enetHeader->fProto = msgdsize(mp) - sizeof(EnetPacketHeader);
// Fill in ethernet source address
OTCopy48BitAddress(hardware_address, enetHeader->fSourceAddr);
// Tell add-on to transmit packet
AO_transmit_packet(mp);
freemsg(mp);
}
/*
* Handle incoming packet (one stream), construct DL_UNITDATA_IND message
*/
static void handle_received_packet(DLPIStream *the_stream, mblk_t *mp, uint16 packet_type, int32 dest_addr_type)
{
// Find address and header length
uint32 addr_len;
uint32 header_len;
switch (packet_type) {
case kPkt8022SAP:
addr_len = kEnetAndSAPAddressLength;
header_len = kEnetPacketHeaderLength + k8022BasicHeaderLength;
break;
case kPkt8022SNAP:
addr_len = kEnetAndSAPAddressLength + k8022SNAPLength;
header_len = kEnetPacketHeaderLength + k8022SNAPHeaderLength;
break;
default: // DIX and IPX
addr_len = kEnetAndSAPAddressLength;
header_len = kEnetPacketHeaderLength;
break;
}
// In Fast Path mode, don't send DL_UNITDATA_IND messages for unicast packets
if ((the_stream->flags & kFastPathMode) && dest_addr_type == keaStandardAddress) {
mp->b_rptr += header_len;
num_rx_fastpath++;
putq(the_stream->rdq, mp);
return;
}
// Allocate the dl_unitdata_ind_t message
mblk_t *nmp;
if ((nmp = allocb(sizeof(dl_unitdata_ind_t) + 2*addr_len, BPRI_HI)) == NULL) {
freemsg(mp);
num_rx_no_unitdata_mem++;
return;
}
// Set message type
nmp->b_datap->db_type = M_PROTO;
dl_unitdata_ind_t *ind = (dl_unitdata_ind_t*)nmp->b_rptr;
ind->dl_primitive = DL_UNITDATA_IND;
nmp->b_wptr += (sizeof(dl_unitdata_ind_t) + 2*addr_len);
// Link M_DATA block
nmp->b_cont = mp;
// Set address fields
ind->dl_dest_addr_length = addr_len;
ind->dl_dest_addr_offset = sizeof(dl_unitdata_ind_t);
ind->dl_src_addr_length = addr_len;
ind->dl_src_addr_offset = sizeof(dl_unitdata_ind_t) + addr_len;
// Set address type
ind->dl_group_address = dest_addr_type;
// Set address fields
T8022FullPacketHeader *packetHeader = (T8022FullPacketHeader *)mp->b_rptr;
T8022AddressStruct *destAddr = ((T8022AddressStruct*)(nmp->b_rptr + ind->dl_dest_addr_offset));
T8022AddressStruct *srcAddr = ((T8022AddressStruct*)(nmp->b_rptr + ind->dl_src_addr_offset));
OTCopy48BitAddress(packetHeader->fEnetPart.fDestAddr, destAddr->fHWAddr);
OTCopy48BitAddress(packetHeader->fEnetPart.fSourceAddr, srcAddr->fHWAddr);
destAddr->fSAP = packetHeader->f8022Part.fDSAP;
srcAddr->fSAP = packetHeader->f8022Part.fSSAP;
if (packet_type == kPkt8022SNAP) {
OTCopy8022SNAP(packetHeader->f8022Part.fSNAP, destAddr->fSNAP);
OTCopy8022SNAP(packetHeader->f8022Part.fSNAP, srcAddr->fSNAP);
}
// "Hide" the ethernet and protocol header(s)
mp->b_rptr += header_len;
// Pass message up the stream
num_unitdata_ind++;
putq(the_stream->rdq, nmp);
return;
}
/*
* Packet received, distribute it to the streams that want it
*/
void ether_packet_received(mblk_t *mp)
{
// Extract address and types
EnetPacketHeader *pkt = (EnetPacketHeader *)mp->b_rptr;
T8022FullPacketHeader *fullpkt = (T8022FullPacketHeader *)pkt;
uint16 sourceSAP, destSAP;
destSAP = fullpkt->fEnetPart.fProto;
if (destSAP >= kMinDIXSAP) {
// Classic ethernet
sourceSAP = destSAP;
} else {
destSAP = fullpkt->f8022Part.fDSAP;
sourceSAP = fullpkt->f8022Part.fSSAP;
}
uint16 packetType = classify_packet_type(sourceSAP, destSAP);
int32 destAddressType = get_address_type(pkt->fDestAddr);
// Look which streams want it
DLPIStream *the_stream, *found_stream = NULL;
uint16 found_packetType = 0;
int32 found_destAddressType = 0;
for (the_stream = dlpi_stream_list; the_stream != NULL; the_stream = mi_next_ptr(the_stream)) {
// Don't send to unbound streams
if (the_stream->dlpi_state == DL_UNBOUND)
continue;
// Does this stream want all 802.2 packets?
if ((the_stream->flags & kAcceptAll8022Packets) && (destSAP <= 0xff))
goto type_found;
// No, check SAP/SNAP
if (destSAP == the_stream->dlsap) {
if (the_stream->flags & kSnapStream) {
// Check SNAPs if necessary
uint8 sum = fullpkt->f8022Part.fSNAP[0] ^ the_stream->snap[0];
sum |= fullpkt->f8022Part.fSNAP[1] ^ the_stream->snap[1];
sum |= fullpkt->f8022Part.fSNAP[2] ^ the_stream->snap[2];
sum |= fullpkt->f8022Part.fSNAP[3] ^ the_stream->snap[3];
sum |= fullpkt->f8022Part.fSNAP[4] ^ the_stream->snap[4];
if (sum == 0)
goto type_found;
} else {
// No SNAP, found a match since saps match
goto type_found;
}
} else {
// Check for an 802.3 Group/Global (odd)
if (((packetType == kPkt8022SAP) || (packetType == kPkt8022SNAP)) && (destSAP & 1) && the_stream->TestGroupSAP(destSAP))
goto type_found;
}
// No stream for this SAP/SNAP found
continue;
type_found:
// If it's a multicast packet, it must be in the stream's multicast list
if ((destAddressType == keaMulticast) && (the_stream->flags & kAcceptMulticasts) && (!the_stream->IsMulticastRegistered(pkt->fDestAddr)))
continue;
// Send packet to stream
// found_stream keeps a pointer to the previously found stream, so that only the last
// stream gets the original message, the other ones get duplicates
if (found_stream)
handle_received_packet(found_stream, dupmsg(mp), found_packetType, found_destAddressType);
found_stream = the_stream;
found_packetType = packetType;
found_destAddressType = destAddressType;
}
// Send original message to last found stream
if (found_stream)
handle_received_packet(found_stream, mp, found_packetType, found_destAddressType);
else {
freemsg(mp); // Nobody wants it *snief*
num_rx_dropped++;
}
}
/*
* Build and send an error acknowledge
*/
static void DLPI_error_ack(DLPIStream *the_stream, queue_t *q, mblk_t *ack_mp, uint32 prim, uint32 err, uint32 uerr)
{
D(bug(" DLPI_error_ack(%p,%p) prim %d, err %d, uerr %d\n", the_stream, ack_mp, prim, err, uerr));
num_error_acks++;
if (ack_mp != NULL)
freemsg(ack_mp);
if ((ack_mp = allocb(sizeof(dl_error_ack_t), BPRI_HI)) == NULL)
return;
ack_mp->b_datap->db_type = M_PCPROTO;
dl_error_ack_t *errp = (dl_error_ack_t *)ack_mp->b_wptr;
errp->dl_primitive = DL_ERROR_ACK;
errp->dl_error_primitive = prim;
errp->dl_errno = err;
errp->dl_unix_errno = uerr;
ack_mp->b_wptr += sizeof(dl_error_ack_t);
qreply(q, ack_mp);
}
/*
* Build and send an OK acknowledge
*/
static void DLPI_ok_ack(DLPIStream *the_stream, queue_t *q, mblk_t *ack_mp, uint32 prim)
{
if (ack_mp->b_datap->db_ref != 1) {
// Message already in use, create a new one
freemsg(ack_mp);
if ((ack_mp = allocb(sizeof(dl_error_ack_t), BPRI_HI)) == NULL)
return;
} else {
// Message free
if (ack_mp->b_cont != NULL) {
freemsg(ack_mp->b_cont);
ack_mp->b_cont = NULL;
}
}
ack_mp->b_datap->db_type = M_PCPROTO;
dl_ok_ack_t *ackp = (dl_ok_ack_t *)ack_mp->b_rptr;
ackp->dl_primitive = DL_OK_ACK;
ackp->dl_correct_primitive = prim;
ack_mp->b_wptr = ack_mp->b_rptr + sizeof(dl_ok_ack_t);
qreply(q, ack_mp);
}
/*
* Handle DL_INFO_REQ (report general information)
*/
static void DLPI_info(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
{
D(bug(" DLPI_info(%p)\n", the_stream));
uint32 saplen = 0;
uint32 addrlen = kEnetPhysicalAddressLength;
uint32 bcastlen = kEnetPhysicalAddressLength;
uint32 hdrlen = kEnetPacketHeaderLength;
// Calculate header length
if (the_stream->dlpi_state != DL_UNBOUND) {
saplen = (the_stream->flags & kSnapStream) ? k8022DLSAPLength+k8022SNAPLength : k8022DLSAPLength;
if (the_stream->dlsap == kSNAPSAP)
hdrlen = kEnetPacketHeaderLength + k8022SNAPHeaderLength; // SNAP address
else if ((the_stream->dlsap <= kMax8022SAP) || (the_stream->dlsap == kIPXSAP))
hdrlen = kEnetPacketHeaderLength + k8022BasicHeaderLength; // SAP or IPX
else
hdrlen = kEnetPacketHeaderLength; // Basic Ethernet
}
// Allocate message block for reply
mblk_t *ack_mp;
if ((ack_mp = allocb(sizeof(dl_info_ack_t) + addrlen + saplen + bcastlen, BPRI_LO)) == NULL) {
DLPI_error_ack(the_stream, q, mp, DL_INFO_REQ, DL_SYSERR, MAC_ENOMEM);
return;
}
// Set up message type
ack_mp->b_datap->db_type = M_PCPROTO;
dl_info_ack_t *ackp = (dl_info_ack_t *)ack_mp->b_rptr;
ackp->dl_primitive = DL_INFO_ACK;
// Info/version fields
ackp->dl_service_mode = DL_CLDLS;
ackp->dl_provider_style = DL_STYLE1;
ackp->dl_version = DL_VERSION_2;
ackp->dl_current_state = the_stream->dlpi_state;
ackp->dl_mac_type = the_stream->framing_8022 ? DL_CSMACD : DL_ETHER;
ackp->dl_reserved = 0;
ackp->dl_qos_length = 0;
ackp->dl_qos_offset = (uint32)DL_UNKNOWN;
ackp->dl_qos_range_length = 0;
ackp->dl_qos_range_offset = (uint32)DL_UNKNOWN;
ackp->dl_growth = 0;
ackp->dl_min_sdu = 1;
ackp->dl_max_sdu = kEnetTSDU - hdrlen;
// Address fields
ackp->dl_sap_length = -saplen; // Negative to indicate sap follows physical address
ackp->dl_addr_length = addrlen + saplen;
ackp->dl_addr_offset = sizeof(dl_info_ack_t);
T8022AddressStruct *boundAddr = ((T8022AddressStruct *)(ack_mp->b_rptr + ackp->dl_addr_offset));
OTCopy48BitAddress(hardware_address, boundAddr->fHWAddr);
if (saplen) {
boundAddr->fSAP = the_stream->dlsap;
if (the_stream->flags & kSnapStream)
OTCopy8022SNAP(the_stream->snap, boundAddr->fSNAP);
}
ackp->dl_brdcst_addr_length = bcastlen;
ackp->dl_brdcst_addr_offset = sizeof(dl_info_ack_t) + addrlen + saplen;
OTSet48BitBroadcastAddress(ack_mp->b_rptr + ackp->dl_brdcst_addr_offset);
// Advance write pointer
ack_mp->b_wptr += sizeof(dl_info_ack_t) + addrlen + saplen + bcastlen;
// Free request
freemsg(mp);
// Send reply
qreply(q, ack_mp);
return;
}
/*
* Handle DL_PHYS_ADDR_REQ (report physical address)
*/
static void DLPI_phys_addr(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
{
D(bug(" DLPI_phys_addr(%p,%p)\n", the_stream, mp));
dl_phys_addr_req_t *req = (dl_phys_addr_req_t *)mp->b_rptr;
// Allocate message block for reply
mblk_t *ack_mp;
if ((ack_mp = allocb(sizeof(dl_phys_addr_ack_t) + kEnetPhysicalAddressLength, BPRI_HI)) == NULL) {
DLPI_error_ack(the_stream, q, mp, DL_PHYS_ADDR_REQ, DL_SYSERR, MAC_ENOMEM);
return;
}
// Set up message type
ack_mp->b_datap->db_type = M_PCPROTO;
dl_phys_addr_ack_t *ackp = (dl_phys_addr_ack_t *)ack_mp->b_wptr;
ackp->dl_primitive = DL_PHYS_ADDR_ACK;
// Fill in address
ackp->dl_addr_length = kEnetPhysicalAddressLength;
ackp->dl_addr_offset = sizeof(dl_phys_addr_ack_t);
ack_mp->b_wptr += sizeof(dl_phys_addr_ack_t) + kEnetPhysicalAddressLength;
if (req->dl_addr_type == DL_CURR_PHYS_ADDR || req->dl_addr_type == DL_FACT_PHYS_ADDR)
OTCopy48BitAddress(hardware_address, ack_mp->b_rptr + ackp->dl_addr_offset);
else {
DLPI_error_ack(the_stream, q, mp, DL_PHYS_ADDR_REQ, DL_BADPRIM, 0);
return;
}
// Free request
freemsg(mp);
// Send reply
qreply(q, ack_mp);
return;
}
/*
* Handle DL_BIND_REQ (bind a stream)
*/
static void DLPI_bind(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
{
dl_bind_req_t *req = (dl_bind_req_t *)mp->b_rptr;
uint32 sap = req->dl_sap;
D(bug(" DLPI_bind(%p,%p) SAP %04x\n", the_stream, mp, sap));
// Stream must be unbound
if (the_stream->dlpi_state != DL_UNBOUND) {
DLPI_error_ack(the_stream, q, mp, DL_BIND_REQ, DL_OUTSTATE, 0);
return;
}
// We only support connectionless data link services
if (req->dl_service_mode != DL_CLDLS || req->dl_max_conind != 0) {
DLPI_error_ack(the_stream, q, mp, DL_BIND_REQ, DL_UNSUPPORTED, 0);
return;
}
// Don't bind to 802.2 group saps, can't check 802.2 global sap (0xFF)
// because it looks like IPX
if ((sap <= kMax8022SAP) && (sap & 1)) {
DLPI_error_ack(the_stream, q, mp, DL_BIND_REQ, DL_BADADDR, 0);
return;
}
if (classify_packet_type(sap, sap) == kPktUnknown) {
DLPI_error_ack(the_stream, q, mp, DL_BIND_REQ, DL_BADADDR, 0);
return;
}
// Allocate message block for reply
mblk_t *ack_mp;
if ((ack_mp = allocb(sizeof(dl_bind_ack_t) + kEnetAndSAPAddressLength, BPRI_HI)) == NULL) {
DLPI_error_ack(the_stream, q, mp, DL_BIND_REQ, DL_SYSERR, MAC_ENOMEM);
return;
}
// Set up message type
ack_mp->b_datap->db_type = M_PCPROTO;
dl_bind_ack_t *ackp = (dl_bind_ack_t *)ack_mp->b_rptr;
ackp->dl_primitive = DL_BIND_ACK;
// Fill in other fields
ackp->dl_sap = sap;
ackp->dl_addr_length = kEnetAndSAPAddressLength;
ackp->dl_addr_offset = sizeof(dl_bind_ack_t);
ackp->dl_max_conind = 0;
ackp->dl_xidtest_flg = 0;
T8022AddressStruct *addrInfo = (T8022AddressStruct *)(ack_mp->b_rptr + sizeof(dl_bind_ack_t));
OTCopy48BitAddress(hardware_address, addrInfo->fHWAddr);
addrInfo->fSAP = sap;
// Must move b_wptr past the address info data
ack_mp->b_wptr = ack_mp->b_rptr + sizeof(dl_bind_ack_t) + kEnetAndSAPAddressLength;
// Set group SAP if necessary
the_stream->ClearAllGroupSAPs();
if (sap <= kMax8022SAP)
the_stream->SetGroupSAP(k8022GlobalSAP);
// The stream is now bound and idle
the_stream->dlpi_state = DL_IDLE;
the_stream->dlsap = sap;
the_stream->flags &= ~kSnapStream;
// Free request
freemsg(mp);
// Send reply
qreply(q, ack_mp);
return;
}
/*
* Handle DL_UNBIND_REQ (unbind a stream)
*/
static void DLPI_unbind(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
{
D(bug(" DLPI_unbind(%p,%p)\n", the_stream, mp));
// Stream must be bound and idle
if (the_stream->dlpi_state != DL_IDLE) {
DLPI_error_ack(the_stream, q, mp, DL_UNBIND_REQ, DL_OUTSTATE, 0);
return;
}
// Stream is now unbound
the_stream->dlpi_state = DL_UNBOUND;
the_stream->dlsap = 0;
// Flush all pending outbound messages
flushq(q, FLUSHDATA);
// Flush all inbound messages pending on the stream
flushq(RD(q), FLUSHDATA);
putnextctl1(RD(q), M_FLUSH, FLUSHRW);
// Send reply
DLPI_ok_ack(the_stream, q, mp, DL_UNBIND_REQ);
return;
}
/*
* Handle DL_SUBS_BIND_REQ (register 802.2 SAP group addresses and SNAPs)
*/
static void DLPI_subs_bind(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
{
dl_subs_bind_req_t *req = (dl_subs_bind_req_t *)mp->b_rptr;
uint8 *sap = ((uint8 *)req) + req->dl_subs_sap_offset;
int32 length = req->dl_subs_sap_length;
uint16 theSap = *((uint16 *)sap);
int32 error = 0;
D(bug(" DLPI_subs_bind(%p,%p) SAP %02x%02x%02x%02x%02x\n", the_stream, mp, sap[0], sap[1], sap[2], sap[3], sap[4]));
// Stream must be idle
if (the_stream->dlpi_state != DL_IDLE) {
DLPI_error_ack(the_stream, q, mp, DL_SUBS_BIND_REQ, DL_OUTSTATE, 0);
return;
}
// Check if address is valid
switch (req->dl_subs_bind_class) {
case DL_PEER_BIND: // Bind a group address
if (the_stream->dlsap <= kMax8022SAP) {
if ((theSap & 1) && (length == sizeof(theSap)))
the_stream->SetGroupSAP(theSap);
else
if (theSap == 0x0000) // special case to receive all 802.2 packets
the_stream->flags |= kAcceptAll8022Packets;
else
error = DL_BADADDR;
} else
error = DL_UNSUPPORTED;
break;
case DL_HIERARCHICAL_BIND: // Bind an additional SNAP
if (the_stream->dlsap == kSNAPSAP) {
if (the_stream->flags & kSnapStream)
error = DL_TOOMANY; // only one SNAP binding allowed
else {
OTCopy8022SNAP(sap, the_stream->snap);
the_stream->flags |= kSnapStream;
}
} else
error = DL_BADADDR;
break;
default:
error = DL_UNSUPPORTED;
break;
}
if (error) {
DLPI_error_ack(the_stream, q, mp, DL_SUBS_BIND_REQ, error, 0);
return;
}
// Allocate message block for reply
mblk_t *ack_mp;
if ((ack_mp = allocb(sizeof(dl_subs_bind_ack_t) + length, BPRI_HI)) == NULL) {
DLPI_error_ack(the_stream, q, mp, DL_SUBS_BIND_REQ, DL_SYSERR, MAC_ENOMEM);
return;
}
// Set up message type
ack_mp->b_datap->db_type = M_PCPROTO;
dl_subs_bind_ack_t *ackp = (dl_subs_bind_ack_t *)ack_mp->b_wptr;
memset(ackp, 0, sizeof(dl_subs_bind_ack_t) + length);
ackp->dl_primitive = DL_SUBS_BIND_ACK;
// Fill in other fields
ackp->dl_subs_sap_length = length;
ackp->dl_subs_sap_offset = length ? sizeof(dl_subs_bind_ack_t) : 0;
ack_mp->b_wptr += sizeof(dl_subs_bind_ack_t);
if (length)
memcpy(ack_mp->b_wptr, sap, length);
ack_mp->b_wptr += length;
// Free request
freemsg(mp);
// Send reply
qreply(q, ack_mp);
return;
}
/*
* Handle DL_SUBS_UNBIND_REQ (unregister 802.2 SAP group addresses and snaps)
*/
static void DLPI_subs_unbind(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
{
dl_subs_unbind_req_t *req = (dl_subs_unbind_req_t *)mp->b_rptr;
uint8 *sap = ((uint8 *)req) + req->dl_subs_sap_offset;
int32 length = req->dl_subs_sap_length;
int32 error = 0;
D(bug(" DLPI_subs_unbind(%p,%p) SAP %02x%02x%02x%02x%02x\n", the_stream, mp, sap[0], sap[1], sap[2], sap[3], sap[4]));
// Stream must be idle
if (the_stream->dlpi_state != DL_IDLE) {
DLPI_error_ack(the_stream, q, mp, DL_SUBS_UNBIND_REQ, DL_OUTSTATE, 0);
return;
}
// Check if we are unbinding from an address we are bound to
if (length == k8022SAPLength) {
if ((*sap & 1) && (*sap != kIPXSAP)) {
if (the_stream->dlsap <= kMax8022SAP)
the_stream->ClearGroupSAP(*sap);
else
error = DL_UNSUPPORTED;
} else
error = DL_BADADDR;
} else if (length == k8022SNAPLength) {
if (the_stream->dlsap == kSNAPSAP) {
if (the_stream->flags & kSnapStream) {
if (memcmp(the_stream->snap, sap, length) != 0)
error = DL_BADADDR;
} else
error = DL_BADADDR;
} else
error = DL_UNSUPPORTED;
}
if (error) {
DLPI_error_ack(the_stream, q, mp, DL_SUBS_UNBIND_REQ, error, 0);
return;
}
// Stream is no longer bound to SNAP
the_stream->flags &= ~kSnapStream;
// Send reply
DLPI_ok_ack(the_stream, q, mp, DL_SUBS_UNBIND_REQ);
return;
}
/*
* Handles DL_ENABMULTI_REQ (enable multicast address)
*/
static void DLPI_enable_multi(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
{
dl_enabmulti_req_t* req = (dl_enabmulti_req_t*)mp->b_rptr;
uint8 *reqaddr = (uint8 *)(mp->b_rptr + req->dl_addr_offset);
D(bug(" DLPI_enable_multi(%p,%p) addr %02x%02x%02x%02x%02x%02x\n", the_stream, mp, reqaddr[0], reqaddr[1], reqaddr[2], reqaddr[3], reqaddr[4], reqaddr[5]));
// Address must be a multicast address
if (get_address_type(reqaddr) != keaMulticast) {
DLPI_error_ack(the_stream, q, mp, DL_ENABMULTI_REQ, DL_BADADDR, 0);
return;
}
// Address already in multicast list?
if (the_stream->IsMulticastRegistered(reqaddr)) {
DLPI_error_ack(the_stream, q, mp, DL_ENABMULTI_REQ, DL_BADADDR, 0);
return;
}
// Tell add-on to enable multicast address
AO_enable_multicast(reqaddr);
// Add new address to multicast list
uint8 *addr = new uint8[kEnetPhysicalAddressLength];
OTCopy48BitAddress(reqaddr, addr);
the_stream->AddMulticast(addr);
// On receive now check multicast packets
the_stream->flags |= kAcceptMulticasts;
// Send reply
DLPI_ok_ack(the_stream, q, mp, DL_ENABMULTI_REQ);
return;
}
/*
* Handles DL_DISABMULTI_REQ (disable multicast address)
*/
static void DLPI_disable_multi(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
{
dl_disabmulti_req_t *req = (dl_disabmulti_req_t*)mp->b_rptr;
uint8 *reqaddr = (uint8 *)(mp->b_rptr + req->dl_addr_offset);
D(bug(" DLPI_disable_multi(%p,%p) addr %02x%02x%02x%02x%02x%02x\n", the_stream, mp, reqaddr[0], reqaddr[1], reqaddr[2], reqaddr[3], reqaddr[4], reqaddr[5]));
// Address must be a multicast address
if (get_address_type(reqaddr) != keaMulticast) {
DLPI_error_ack(the_stream, q, mp, DL_DISABMULTI_REQ, DL_BADADDR, 0);
return;
}
// Find address in multicast list
uint8 *addr = the_stream->IsMulticastRegistered(reqaddr);
if (addr == NULL) {
DLPI_error_ack(the_stream, q, mp, DL_DISABMULTI_REQ, DL_BADADDR, 0);
return;
}
// Found, then remove
the_stream->RemoveMulticast(addr);
delete addr;
// Tell add-on to disable multicast address
AO_disable_multicast(reqaddr);
// No longer check multicast packets if no multicast addresses are registered
if (the_stream->multicast_list == NULL)
the_stream->flags &= ~kAcceptMulticasts;
// Send reply
DLPI_ok_ack(the_stream, q, mp, DL_DISABMULTI_REQ);
return;
}
/*
* Handle DL_UNITDATA_REQ (transmit packet)
*/
static void DLPI_unit_data(DLPIStream *the_stream, queue_t *q, mblk_t *mp)
{
D(bug(" DLPI_unit_data(%p,%p)\n", the_stream, mp));
dl_unitdata_req_t *req = (dl_unitdata_req_t *)mp->b_rptr;
// Stream must be idle
if (the_stream->dlpi_state != DL_IDLE) {
// Not idle, send error response
dl_uderror_ind_t *errp;
mblk_t *bp;
int i = sizeof(dl_uderror_ind_t) + req->dl_dest_addr_length;
if ((bp = allocb(i, BPRI_HI)) == NULL) {
freemsg(mp);
return;
}
bp->b_datap->db_type = M_PROTO;
errp = (dl_uderror_ind_t *)bp->b_wptr;
errp->dl_primitive = DL_UDERROR_IND;
errp->dl_errno = DL_OUTSTATE;
errp->dl_unix_errno = 0;
errp->dl_dest_addr_length = req->dl_dest_addr_length;
errp->dl_dest_addr_offset = sizeof(dl_uderror_ind_t);
bp->b_wptr += sizeof(dl_uderror_ind_t);
memcpy((uint8 *)bp->b_wptr, ((uint8 *)req) + req->dl_dest_addr_offset, req->dl_dest_addr_length);
bp->b_wptr += req->dl_dest_addr_length;
qreply(q, bp);
freemsg(mp);
return;
}
// Build packet header and transmit packet
if ((mp = build_tx_packet_header(the_stream, mp, false)) != NULL)
transmit_packet(mp);
}
Reference in New Issue View Git Blame Copy Permalink