topical media & game development
lib-of-vs-libs-QTDevWin-CIncludes-OpenTransportProviders.h / h
/*
File: OpenTransportProviders.h
Contains: This file contains provider-specific definitions for various built-in providers.
Version: Technology: 2.5
Release: QuickTime 6.0.2
Copyright: (c) 1993-2001 by Apple Computer, Inc. and Mentat Inc., all rights reserved.
Bugs?: For bug reports, consult the following page on
the World Wide Web:
http://developer.apple.com/bugreporter/
*/
ifndef __OPENTRANSPORTPROVIDERS__
define __OPENTRANSPORTPROVIDERS__
ifndef __OPENTRANSPORT__
include <OpenTransport.h>
endif
if PRAGMA_ONCE
#pragma once
endif
ifdef __cplusplus
extern "C" {
endif
if PRAGMA_IMPORT
#pragma import on
endif
if PRAGMA_STRUCT_ALIGN
#pragma options align=mac68k
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
endif
if defined(__MWERKS__) && TARGET_CPU_68K
#pragma push
#pragma pointers_in_D0
endif
/* ***** TCP/IP ******/
/* Basic types*/
typedef UInt16 InetPort;
typedef UInt32 InetHost;
/* Enums used as address type designations.*/
ifndef AF_INET /* might conflict with BSD headers */
enum {
AF_INET = 2, /* Traditonal*/
AF_DNS = 42 /* Obviously, the answer to...*/
};
else
enum {
AF_DNS = 42 // Obviously, the answer to...
};
endif
/*
Enum which can be used to bind to all IP interfaces
rather than a specific one.
*/
enum {
kOTAnyInetAddress = 0 /* Wildcard*/
};
/*
Define the InetSvcRef type. This type needs special
processing because in C++ it's a subclass of TProvider.
See the definition of TEndpointRef in <OpenTransport.h>
for the logic behind this definition.
*/
ifdef __cplusplus
typedef class TInternetServices* InetSvcRef;
else
typedef void* InetSvcRef;
endif
define kDefaultInternetServicesPath ((OTConfigurationRef)-3L)
/* Shared library prefixes*/
define kInetVersion "3.1.1"
define kInetPrefix "ot:inet
not a real XTI option
TCP_ABORT_THRESHOLD = 0x11,
not a real XTI option
TCP_CONN_NOTIFY_THRESHOLD = 0x12,
not a real XTI option
TCP_CONN_ABORT_THRESHOLD = 0x13,
not a real XTI option
TCP_OOBINLINE = 0x14,
not a real XTI option
TCP_URGENT_PTR_TYPE = 0x15,
not a real XTI option
TCP_KEEPALIVE = 0x0008 /* keepalive defined in OpenTransport.h */
};
enum {
T_GARBAGE = 2
};
/* UDP Level Options*/
enum {
UDP_CHECKSUM = 0x0600,
UDP_RX_ICMP = 0x02
};
/* IP Level Options*/
enum {
kIP_OPTIONS = 0x01,
kIP_TOS = 0x02,
kIP_TTL = 0x03,
kIP_REUSEADDR = 0x04,
kIP_DONTROUTE = 0x10,
kIP_BROADCAST = 0x20,
kIP_REUSEPORT = 0x0200,
kIP_HDRINCL = 0x1002,
kIP_RCVOPTS = 0x1005,
kIP_RCVDSTADDR = 0x1007,
kIP_MULTICAST_IF = 0x1010, /* set/get IP multicast interface */
kIP_MULTICAST_TTL = 0x1011, /* set/get IP multicast timetolive */
kIP_MULTICAST_LOOP = 0x1012, /* set/get IP multicast loopback */
kIP_ADD_MEMBERSHIP = 0x1013, /* add an IP group membership */
kIP_DROP_MEMBERSHIP = 0x1014, /* drop an IP group membership */
kIP_BROADCAST_IFNAME = 0x1015, /* Set interface for broadcasts */
kIP_RCVIFADDR = 0x1016 /* Set interface for broadcasts */
};
/*
* The value of some of the following constants may conflict with
* the values found in the BSD header netinet/in.h.
* Use instead the constant defined in the enum, for example use
* kIP_OPTIONS instead of IP_OPTIONS.
*/
ifndef IP_OPTIONS
enum {
IP_OPTIONS = kIP_OPTIONS,
IP_TOS = kIP_TOS,
IP_TTL = kIP_TTL,
IP_REUSEADDR = kIP_REUSEADDR,
IP_DONTROUTE = kIP_DONTROUTE,
IP_BROADCAST = kIP_BROADCAST,
IP_REUSEPORT = kIP_REUSEPORT,
IP_HDRINCL = kIP_HDRINCL,
IP_RCVOPTS = kIP_RCVOPTS,
IP_RCVDSTADDR = kIP_RCVDSTADDR,
IP_MULTICAST_IF = kIP_MULTICAST_IF, /* set/get IP multicast interface */
IP_MULTICAST_TTL = kIP_MULTICAST_TTL, /* set/get IP multicast timetolive */
IP_MULTICAST_LOOP = kIP_MULTICAST_LOOP, /* set/get IP multicast loopback */
IP_ADD_MEMBERSHIP = kIP_ADD_MEMBERSHIP, /* add an IP group membership */
IP_DROP_MEMBERSHIP = kIP_DROP_MEMBERSHIP, /* drop an IP group membership */
IP_BROADCAST_IFNAME = kIP_BROADCAST_IFNAME, /* Set interface for broadcasts */
IP_RCVIFADDR = kIP_RCVIFADDR /* Set interface for broadcasts */
};
endif
enum {
DVMRP_INIT = 100, /* DVMRP-specific setsockopt commands, from ip_mroute.h*/
DVMRP_DONE = 101,
DVMRP_ADD_VIF = 102,
DVMRP_DEL_VIF = 103,
DVMRP_ADD_LGRP = 104,
DVMRP_DEL_LGRP = 105,
DVMRP_ADD_MRT = 106,
DVMRP_DEL_MRT = 107
};
/* IP_TOS precdence levels*/
enum {
T_ROUTINE = 0,
T_PRIORITY = 1,
T_IMMEDIATE = 2,
T_FLASH = 3,
T_OVERRIDEFLASH = 4,
T_CRITIC_ECP = 5,
T_INETCONTROL = 6,
T_NETCONTROL = 7
};
/* IP_TOS type of service*/
enum {
T_NOTOS = 0x00,
T_LDELAY = (1 << 4),
T_HITHRPT = (1 << 3),
T_HIREL = (1 << 2)
};
define SET_TOS(prec,tos) (((0x7 & (prec)) << 5) | (0x1c & (tos)))
/* IP Multicast option structures*/
struct TIPAddMulticast {
InetHost multicastGroupAddress;
InetHost interfaceAddress;
};
typedef struct TIPAddMulticast TIPAddMulticast;
/* Protocol-specific events*/
enum {
T_DNRSTRINGTOADDRCOMPLETE = kPRIVATEEVENT + 1,
T_DNRADDRTONAMECOMPLETE = kPRIVATEEVENT + 2,
T_DNRSYSINFOCOMPLETE = kPRIVATEEVENT + 3,
T_DNRMAILEXCHANGECOMPLETE = kPRIVATEEVENT + 4,
T_DNRQUERYCOMPLETE = kPRIVATEEVENT + 5
};
/* InetAddress*/
struct InetAddress {
OTAddressType fAddressType; /* always AF_INET*/
InetPort fPort; /* Port number */
InetHost fHost; /* Host address in net byte order*/
UInt8 fUnused[8]; /* Traditional unused bytes*/
};
typedef struct InetAddress InetAddress;
/* Domain Name Resolver (DNR) */
enum {
kMaxHostAddrs = 10,
kMaxSysStringLen = 32,
kMaxHostNameLen = 255
};
typedef char InetDomainName[256];
struct InetHostInfo {
InetDomainName name;
InetHost addrs[10];
};
typedef struct InetHostInfo InetHostInfo;
struct InetSysInfo {
char cpuType[32];
char osType[32];
};
typedef struct InetSysInfo InetSysInfo;
struct InetMailExchange {
UInt16 preference;
InetDomainName exchange;
};
typedef struct InetMailExchange InetMailExchange;
struct DNSQueryInfo {
UInt16 qType;
UInt16 qClass;
UInt32 ttl;
InetDomainName name;
UInt16 responseType; /* answer, authority, or additional*/
UInt16 resourceLen; /* actual length of array which follows*/
char resourceData[4]; /* size varies*/
};
typedef struct DNSQueryInfo DNSQueryInfo;
/* DNSAddress*/
/*
The DNSAddress format is optional and may be used in connects,
datagram sends, and resolve address calls. The name takes the
format "somewhere.com" or "somewhere.com:portnumber" where
the ":portnumber" is optional. The length of this structure
is arbitrarily limited to the overall max length of a domain
name (255 chars), although a longer one can be use successfully
if you use this as a template for doing so. However, the domain name
is still limited to 255 characters.
*/
struct DNSAddress {
OTAddressType fAddressType; /* always AF_DNS*/
InetDomainName fName;
};
typedef struct DNSAddress DNSAddress;
/* InetInterfaceInfo*/
enum {
kDefaultInetInterface = -1
};
enum {
kInetInterfaceInfoVersion = 3
};
struct InetInterfaceInfo {
InetHost fAddress;
InetHost fNetmask;
InetHost fBroadcastAddr;
InetHost fDefaultGatewayAddr;
InetHost fDNSAddr;
UInt16 fVersion;
UInt16 fHWAddrLen;
UInt8 * fHWAddr;
UInt32 fIfMTU;
UInt8 * fReservedPtrs[2];
InetDomainName fDomainName;
UInt32 fIPSecondaryCount;
UInt8 fReserved[252];
};
typedef struct InetInterfaceInfo InetInterfaceInfo;
/* InetDHCPOption*/
enum {
kAllDHCPOptions = -1,
kDHCPLongOption = 126,
kDHCPLongOptionReq = 127
};
struct InetDHCPOption {
UInt8 fOptionTag;
UInt8 fOptionLen;
UInt8 fOptionValue;
};
typedef struct InetDHCPOption InetDHCPOption;
/* TCP/IP Utility Routines*/
EXTERN_API( void )
OTInitInetAddress (InetAddress * addr,
InetPort port,
InetHost host);
EXTERN_API( OTByteCount )
OTInitDNSAddress (DNSAddress * addr,
char * str);
EXTERN_API( OSStatus )
OTInetStringToHost (char * str,
InetHost * host);
EXTERN_API( void )
OTInetHostToString (InetHost host,
char * str);
EXTERN_API( OSStatus )
OTInetGetInterfaceInfo (InetInterfaceInfo * info,
SInt32 val);
EXTERN_API( OSStatus )
OTInetGetSecondaryAddresses (InetHost * addr,
UInt32 * count,
SInt32 val);
if CALL_NOT_IN_CARBON
EXTERN_API( OSStatus )
OTInetGetDHCPConfigInfo (InetDHCPOption * buf,
UInt32 bufSize,
SInt32 index,
SInt32 opt);
/* InetServices & DNR Calls*/
endif /* CALL_NOT_IN_CARBON */
if !OTKERNEL
/*
Under Carbon, OTOpenInternetServices routines take a client context pointer. Applications may pass NULL
after calling InitOpenTransport(kInitOTForApplicationMask, ...). Non-applications must always pass a
valid client context.
*/
EXTERN_API( InetSvcRef )
OTOpenInternetServicesInContext (OTConfigurationRef cfig,
OTOpenFlags oflag,
OSStatus * err,
OTClientContextPtr clientContext);
EXTERN_API( OSStatus )
OTAsyncOpenInternetServicesInContext (OTConfigurationRef cfig,
OTOpenFlags oflag,
OTNotifyUPP upp,
void * contextPtr,
OTClientContextPtr clientContext);
if CALL_NOT_IN_CARBON
EXTERN_API( InetSvcRef )
OTOpenInternetServices (OTConfigurationRef cfig,
OTOpenFlags oflag,
OSStatus * err);
EXTERN_API( OSStatus )
OTAsyncOpenInternetServices (OTConfigurationRef cfig,
OTOpenFlags oflag,
OTNotifyProcPtr proc,
void * contextPtr);
endif /* CALL_NOT_IN_CARBON */
if TARGET_API_MAC_CARBON
/* The following macro may be used by applications only.*/
define OTOpenInternetServices(cfig, oflags, err) OTOpenInternetServicesInContext(cfig, oflags, err, NULL)
define OTAsyncOpenInternetServices(cfig, oflags, proc, contextPtr) OTAsyncOpenInternetServicesInContext(cfig, oflags, proc, contextPtr, NULL)
endif /* TARGET_API_MAC_CARBON */
EXTERN_API( OSStatus )
OTInetStringToAddress (InetSvcRef ref,
char * name,
InetHostInfo * hinfo);
EXTERN_API( OSStatus )
OTInetAddressToName (InetSvcRef ref,
InetHost addr,
InetDomainName name);
EXTERN_API( OSStatus )
OTInetSysInfo (InetSvcRef ref,
char * name,
InetSysInfo * sysinfo);
EXTERN_API( OSStatus )
OTInetMailExchange (InetSvcRef ref,
char * name,
UInt16 * num,
InetMailExchange * mx);
EXTERN_API( OSStatus )
OTInetQuery (InetSvcRef ref,
char * name,
UInt16 qClass,
UInt16 qType,
char * buf,
OTByteCount buflen,
void ** argv,
OTByteCount argvlen,
OTFlags flags);
ifdef __cplusplus
} // Terminate C definitions
class TInternetServices : public TProvider
{
public:
OSStatus StringToAddress(char* name, InetHostInfo* hinfo)
{ return OTInetStringToAddress(this, name, hinfo); }
OSStatus AddressToName(InetHost addr, InetDomainName name)
{ return OTInetAddressToName(this, addr, name); }
OSStatus SysInfo(char* name, InetSysInfo* sysinfo )
{ return OTInetSysInfo(this, name, sysinfo); }
OSStatus MailExchange(char* name, UInt16* num, InetMailExchange* mx)
{ return OTInetMailExchange(this, name, num, mx); }
OSStatus Query(char* name, UInt16 qClass, UInt16 qType,
char* buf, OTByteCount buflen,
void** argv, OTByteCount argvlen,
OTFlags flags)
{ return OTInetQuery(this, name, qClass, qType, buf, buflen, argv, argvlen, flags); }
};
extern "C" { /* resume C definitions */
endif
endif /* !OTKERNEL */
/* ***** AppleTalk ******/
/* Shared library prefixes*/
define kATalkVersion "1.1"
define kATalkPrefix "ot:atlk"
define kATBinderID "ot:atbd
*****************************************************************************
* Module definitions
******************************************************************************
/* XTI Levels*/
enum {
ATK_DDP = FOUR_CHAR_CODE('DDP '),
ATK_AARP = FOUR_CHAR_CODE('AARP'),
ATK_ATP = FOUR_CHAR_CODE('ATP '),
ATK_ADSP = FOUR_CHAR_CODE('ADSP'),
ATK_ASP = FOUR_CHAR_CODE('ASP '),
ATK_PAP = FOUR_CHAR_CODE('PAP '),
ATK_NBP = FOUR_CHAR_CODE('NBP '),
ATK_ZIP = FOUR_CHAR_CODE('ZIP ')
};
/* Module Names*/
define kDDPName "ddp"
define kATPName "atp"
define kADSPName "adsp"
define kASPName "asp"
define kPAPName "pap"
define kNBPName "nbp"
define kZIPName "zip"
define kLTalkName "ltlk"
define kLTalkAName "ltlkA"
define kLTalkBName "ltlkB"
/*
Protocol-specific Options
NOTE:
All Protocols support OPT_CHECKSUM (Value is (unsigned long)T_YES/T_NO)
ATP supports OPT_RETRYCNT (# Retries, 0 = try once) and
OPT_INTERVAL (# Milliseconds to wait)
*/
enum {
DDP_OPT_CHECKSUM = 0x0600,
DDP_OPT_SRCADDR = 0x2101, /* DDP UnitDataReq Only - set src address, Value is DDPAddress */
ATP_OPT_REPLYCNT = 0x2110, /* AppleTalk - ATP Resp Pkt Ct Type, Value is (unsigned long) pkt count */
ATP_OPT_DATALEN = 0x2111, /* AppleTalk - ATP Pkt Data Len Type, Value is (unsigned long) length */
ATP_OPT_RELTIMER = 0x2112, /* AppleTalk - ATP Release Timer Type, Value is (unsigned long) timer, (See Inside AppleTalk, second edition */
ATP_OPT_TRANID = 0x2113, /* Value is (unsigned long) Boolean, Used to request Transaction ID, Returned with Transaction ID on requests */
PAP_OPT_OPENRETRY = 0x2120 /* AppleTalk - PAP OpenConn Retry count, Value is (unsigned long) T_YES/T_NO */
};
/* Protocol-Specific Events*/
/*
If you send the IOCTL: OTIoctl(I_OTGetMiscellaneousEvents, 1),
you will receive the T_ATALKxxx events on your endpoint.
NOTE: The endpoint does not need to be bound.
*/
enum {
kAppleTalkEvent = kPROTOCOLEVENT | 0x00010000,
T_GETMYZONECOMPLETE = kAppleTalkEvent + 1,
T_GETLOCALZONESCOMPLETE = kAppleTalkEvent + 2,
T_GETZONELISTCOMPLETE = kAppleTalkEvent + 3,
T_GETATALKINFOCOMPLETE = kAppleTalkEvent + 4,
T_ATALKROUTERDOWNEVENT = kAppleTalkEvent + 51, /* No routers have been seen for a while. If the cookie is NULL, all routers are gone. Otherwise, there is still an ARA router hanging around being used, and only the local cable has been timed out.*/
T_ATALKROUTERUPEVENT = kAppleTalkEvent + 52, /* We didn't have a router, but now one has come up. Cookie is NULL for a normal router coming up, non-NULL for an ARA router coming on-line*/
T_ATALKZONENAMECHANGEDEVENT = kAppleTalkEvent + 53, /* A Zone name change was issued from the router, so our AppleTalk Zone has changed.*/
T_ATALKCONNECTIVITYCHANGEDEVENT = kAppleTalkEvent + 54, /* An ARA connection was established (cookie != NULL), or was disconnected (cookie == NULL)*/
T_ATALKINTERNETAVAILABLEEVENT = kAppleTalkEvent + 55, /* A router has appeared, and our address is in the startup range. Cookie is hi/lo of new cable range.*/
T_ATALKCABLERANGECHANGEDEVENT = kAppleTalkEvent + 56 /* A router has appeared, and it's incompatible with our current address. Cookie is hi/lo of new cable range.*/
};
enum {
kAllATalkRoutersDown = 0, /* This indicates that all routers are offline*/
kLocalATalkRoutersDown = -1L, /* This indicates that all local routers went offline, but an ARA router is still active*/
kARARouterDisconnected = -2L /* This indicates that ARA was disconnected, do it's router went offline, and we have no local routers to fall back onto.*/
};
enum {
kARARouterOnline = -1L, /* We had no local routers, but an ARA router is now online.*/
kATalkRouterOnline = 0, /* We had no routers, but a local router is now online*/
kLocalATalkRouterOnline = -2L /* We have an ARA router, but now we've seen a local router as well*/
};
define IsAppleTalkEvent(x) ((x) & 0xffff0000) == kAppleTalkEvent)
/* Protocol-specific IOCTLs*/
enum {
ATALK_IOC_FULLSELFSEND = ((MIOC_ATALK << 8) | 47), /* Turn on/off full self-send (it's automatic for non-backward-compatible links)*/
ADSP_IOC_FORWARDRESET = ((MIOC_ATALK << 8) | 60) /* ADSP Forward Reset*/
};
/* Protocol-specific constants*/
/* ECHO*/
enum {
kECHO_TSDU = 585 /* Max. # of data bytes.*/
};
/* NBP*/
enum {
kNBPMaxNameLength = 32,
kNBPMaxTypeLength = 32,
kNBPMaxZoneLength = 32,
kNBPSlushLength = 9, /* Extra space for @, : and a few escape chars*/
kNBPMaxEntityLength = (kNBPMaxNameLength + kNBPMaxTypeLength + kNBPMaxZoneLength + 3),
kNBPEntityBufferSize = (kNBPMaxNameLength + kNBPMaxTypeLength + kNBPMaxZoneLength + kNBPSlushLength),
kNBPWildCard = 0x3D, /* NBP name and type match anything '='*/
kNBPImbeddedWildCard = 0xC5, /* NBP name and type match some '*'*/
kNBPDefaultZone = 0x2A /* NBP default zone '*'*/
};
/* ZIP*/
enum {
kZIPMaxZoneLength = kNBPMaxZoneLength
};
enum {
kDDPAddressLength = 8, /* value to use in netbuf.len field, Maximum length of AppleTalk address*/
kNBPAddressLength = kNBPEntityBufferSize,
kAppleTalkAddressLength = kDDPAddressLength + kNBPEntityBufferSize
};
define OTCopyDDPAddress(addr, dest) \
{ \
((UInt32*)(dest))[0] = ((UInt32*)(addr))[0]; \
((UInt32*)(dest))[1] = ((UInt32*)(addr))[1]; \
}
*****************************************************************************
* CLASS TAppleTalkServices
******************************************************************************
if !OTKERNEL
/*
Define the ATSvcRef type. This type needs special
processing because in C++ it's a subclass of TProvider.
See the definition of TEndpointRef in <OpenTransport.h>
for the logic behind this definition.
*/
ifdef __cplusplus
typedef class TAppleTalkServices* ATSvcRef;
else
typedef void* ATSvcRef;
endif
define kDefaultAppleTalkServicesPath ((OTConfigurationRef)-3L)
/*
Under Carbon, OpenAppleTalkServices routines take a client context pointer. Applications may pass NULL
after calling InitOpenTransport(kInitOTForApplicationMask, ...). Non-applications must always pass a
valid client context.
*/
EXTERN_API( OSStatus )
OTAsyncOpenAppleTalkServicesInContext (OTConfigurationRef cfig,
OTOpenFlags flags,
OTNotifyUPP proc,
void * contextPtr,
OTClientContextPtr clientContext);
EXTERN_API( ATSvcRef )
OTOpenAppleTalkServicesInContext (OTConfigurationRef cfig,
OTOpenFlags flags,
OSStatus * err,
OTClientContextPtr clientContext);
if CALL_NOT_IN_CARBON
EXTERN_API( OSStatus )
OTAsyncOpenAppleTalkServices (OTConfigurationRef cfig,
OTOpenFlags flags,
OTNotifyProcPtr proc,
void * contextPtr);
EXTERN_API( ATSvcRef )
OTOpenAppleTalkServices (OTConfigurationRef cfig,
OTOpenFlags flags,
OSStatus * err);
endif /* CALL_NOT_IN_CARBON */
if TARGET_API_MAC_CARBON
/* The following macro may be used by applications only.*/
define OTOpenAppleTalkServices(cfig, oflags, err) OTOpenAppleTalkServicesInContext(cfig, oflags, err, NULL)
define OTAsyncOpenAppleTalkServices(cfig, oflags, proc, contextPtr) OTAsyncOpenAppleTalkServicesInContext(cfig, oflags, proc, contextPtr, NULL)
endif /* TARGET_API_MAC_CARBON */
/* Get the zone associated with the ATSvcRef*/
EXTERN_API( OSStatus )
OTATalkGetMyZone (ATSvcRef ref,
TNetbuf * zone);
/*
Get the list of available zones associated with the local cable
of the ATSvcRef
*/
EXTERN_API( OSStatus )
OTATalkGetLocalZones (ATSvcRef ref,
TNetbuf * zones);
/* Get the list of all zones on the internet specified by the ATSvcRef*/
EXTERN_API( OSStatus )
OTATalkGetZoneList (ATSvcRef ref,
TNetbuf * zones);
/* Stores an AppleTalkInfo structure into the TNetbuf (see later in this file)*/
EXTERN_API( OSStatus )
OTATalkGetInfo (ATSvcRef ref,
TNetbuf * info);
ifdef __cplusplus
} // Terminate C definitions
class TAppleTalkServices : public TProvider
{
public:
OSStatus GetMyZone(TNetbuf* zone) { return OTATalkGetMyZone(this, zone); }
OSStatus GetLocalZones(TNetbuf* zones) { return OTATalkGetLocalZones(this, zones); }
OSStatus GetZoneList(TNetbuf* zones) { return OTATalkGetZoneList(this, zones); }
OSStatus GetInfo(TNetbuf* info) { return OTATalkGetInfo(this, info); }
};
extern "C" { /* resume C definitions */
endif /* _cplus */
endif /* !OTKERNEL */
/* AppleTalk Addressing*/
/*
The NBPEntity structure is used to manipulate NBP names without regard
to issues of what kind of "special" characters are in the name.
When stored as an address in an NBPAddress or DDPNBPAddress, they are
stored as a character string, which is currently just ASCII, but in the
future may be UniChar, or some other internationalizable scripting set.
The string following an NBPAddress or DDPNBPAddress is intended to be
suitable for showing to users, whereas NBPEntity is not.
WARNING: NBPAddress and DDPNBPAddress structures do not "know" the length
of the address. That must have been obtained as part of a Lookup or
ResolveAddress call.
*/
enum {
AF_ATALK_FAMILY = 0x0100,
AF_ATALK_DDP = 0x0100,
AF_ATALK_DDPNBP = AF_ATALK_FAMILY + 1,
AF_ATALK_NBP = AF_ATALK_FAMILY + 2,
AF_ATALK_MNODE = AF_ATALK_FAMILY + 3
};
struct NBPEntity {
UInt8 fEntity[99];
};
typedef struct NBPEntity NBPEntity;
struct DDPAddress {
OTAddressType fAddressType; /* One of the enums above*/
UInt16 fNetwork;
UInt8 fNodeID;
UInt8 fSocket;
UInt8 fDDPType;
UInt8 fPad;
ifdef __cplusplus
// C++ inline methods on this structure.
void Init(const DDPAddress&);
void Init(UInt16 net, UInt8 node, UInt8 socket);
void Init(UInt16 net, UInt8 node, UInt8 socket, UInt8 type);
void SetSocket(UInt8);
void SetType(UInt8);
void SetNode(UInt8);
void SetNetwork(UInt16);
OTByteCount GetAddressLength() const;
OTAddressType GetAddressType() const;
UInt8 GetSocket() const;
UInt8 GetType() const;
UInt8 GetNode() const;
UInt16 GetNetwork() const;
Boolean operator==(const DDPAddress&) const;
Boolean operator!=(const DDPAddress&) const;
void operator=(const DDPAddress&);
endif
};
typedef struct DDPAddress DDPAddress;
struct NBPAddress {
OTAddressType fAddressType; /* One of the enums above*/
UInt8 fNBPNameBuffer[105];
ifdef __cplusplus
// C++ inline methods on this structure.
OTByteCount Init();
OTByteCount Init(const NBPEntity&);
OTByteCount Init(const char*);
OTByteCount Init(const char*, OTByteCount len);
Boolean ExtractEntity(NBPEntity&, OTByteCount len);
OTAddressType GetAddressType() const;
endif
};
typedef struct NBPAddress NBPAddress;
struct DDPNBPAddress {
OTAddressType fAddressType; /* One of the enums above*/
UInt16 fNetwork;
UInt8 fNodeID;
UInt8 fSocket;
UInt8 fDDPType;
UInt8 fPad;
UInt8 fNBPNameBuffer[105];
ifdef __cplusplus
// C++ inline methods on this structure.
void Init(const DDPAddress&);
void Init(UInt16 net, UInt8 node, UInt8 socket);
void Init(UInt16 net, UInt8 node, UInt8 socket, UInt8 type);
void SetSocket(UInt8);
void SetType(UInt8);
void SetNode(UInt8);
void SetNetwork(UInt16);
OTAddressType GetAddressType() const;
UInt8 GetSocket() const;
UInt8 GetType() const;
UInt8 GetNode() const;
UInt16 GetNetwork() const;
Boolean ExtractEntity(NBPEntity&, OTByteCount len);
OTByteCount SetNBPEntity(const NBPEntity&);
OTByteCount SetNBPEntity(const char*);
OTByteCount SetNBPEntity(const char*, OTByteCount len);
Boolean operator==(const DDPAddress&) const;
endif
};
typedef struct DDPNBPAddress DDPNBPAddress;
/* These are some utility routines for dealing with NBP and DDP addresses. */
/* Functions to initialize the various AppleTalk Address types*/
EXTERN_API( void )
OTInitDDPAddress (DDPAddress * addr,
UInt16 net,
UInt8 node,
UInt8 socket,
UInt8 ddpType);
EXTERN_API( OTByteCount )
OTInitNBPAddress (NBPAddress * addr,
const char * name);
EXTERN_API( OTByteCount )
OTInitDDPNBPAddress (DDPNBPAddress * addr,
const char * name,
UInt16 net,
UInt8 node,
UInt8 socket,
UInt8 ddpType);
/* Compare 2 DDP addresses for equality*/
EXTERN_API( Boolean )
OTCompareDDPAddresses (const DDPAddress * addr1,
const DDPAddress * addr2);
/* Init an NBPEntity to a NULL name*/
EXTERN_API( void )
OTInitNBPEntity (NBPEntity * entity);
/* Get the length an NBPEntity would have when stored as an address*/
EXTERN_API( OTByteCount )
OTGetNBPEntityLengthAsAddress (const NBPEntity * entity);
/* Store an NBPEntity into an address buffer*/
EXTERN_API( OTByteCount )
OTSetAddressFromNBPEntity (UInt8 * nameBuf,
const NBPEntity * entity);
/* Create an address buffer from a string (use -1 for len to use strlen)*/
EXTERN_API( OTByteCount )
OTSetAddressFromNBPString (UInt8 * addrBuf,
const char * name,
SInt32 len);
/*
Create an NBPEntity from an address buffer. False is returned if
the address was truncated.
*/
EXTERN_API( Boolean )
OTSetNBPEntityFromAddress (NBPEntity * entity,
const UInt8 * addrBuf,
OTByteCount len);
/* Routines to set a piece of an NBP entity from a character string*/
EXTERN_API( Boolean )
OTSetNBPName (NBPEntity * entity,
const char * name);
EXTERN_API( Boolean )
OTSetNBPType (NBPEntity * entity,
const char * typeVal);
EXTERN_API( Boolean )
OTSetNBPZone (NBPEntity * entity,
const char * zone);
/* Routines to extract pieces of an NBP entity*/
EXTERN_API( void )
OTExtractNBPName (const NBPEntity * entity,
char * name);
EXTERN_API( void )
OTExtractNBPType (const NBPEntity * entity,
char * typeVal);
EXTERN_API( void )
OTExtractNBPZone (const NBPEntity * entity,
char * zone);
ifdef __cplusplus
// Inline methods for DDPAddress
inline void DDPAddress::operator=(const DDPAddress& addr)
{
*(UInt32*)&fAddressType = *(UInt32*)&addr.fAddressType;
*(UInt32*)&fNodeID = *(UInt32*)&addr.fNodeID;
}
inline Boolean DDPAddress::operator==(const DDPAddress& addr) const
{
return OTCompareDDPAddresses(&addr, this);
}
inline Boolean DDPAddress::operator!=(const DDPAddress& addr) const
{
return !OTCompareDDPAddresses(&addr, this);
}
inline void DDPAddress::SetSocket(UInt8 socket)
{
fSocket = socket;
}
inline void DDPAddress::SetNode(UInt8 node)
{
fNodeID = node;
}
inline void DDPAddress::SetType(UInt8 type)
{
fDDPType = type;
}
inline void DDPAddress::SetNetwork(UInt16 net)
{
fNetwork = net;
}
inline OTByteCount DDPAddress::GetAddressLength() const
{
return kDDPAddressLength;
}
inline OTAddressType DDPAddress::GetAddressType() const
{
return fAddressType;
}
inline UInt8 DDPAddress::GetSocket() const
{
return fSocket;
}
inline UInt8 DDPAddress::GetNode() const
{
return fNodeID;
}
inline UInt8 DDPAddress::GetType() const
{
return fDDPType;
}
inline UInt16 DDPAddress::GetNetwork() const
{
return fNetwork;
}
inline void DDPAddress::Init(UInt16 net, UInt8 node,
UInt8 socket)
{
fAddressType = AF_ATALK_DDP;
SetNetwork(net);
SetNode(node);
SetSocket(socket);
SetType(0);
}
inline void DDPAddress::Init(UInt16 net, UInt8 node,
UInt8 socket, UInt8 type)
{
fAddressType = AF_ATALK_DDP;
SetNetwork(net);
SetNode(node);
SetSocket(socket);
SetType(type);
}
inline void DDPAddress::Init(const DDPAddress& addr)
{
*(UInt32*)&fAddressType = *(UInt32*)&addr.fAddressType;
*(UInt32*)&fNodeID = *(UInt32*)&addr.fNodeID;
}
// Inline methods for NBPAddress
inline OTByteCount NBPAddress::Init()
{
fAddressType = AF_ATALK_NBP;
return sizeof(OTAddressType);
}
inline OTByteCount NBPAddress::Init(const NBPEntity& addr)
{
fAddressType = AF_ATALK_NBP;
return sizeof(OTAddressType) + OTSetAddressFromNBPEntity(fNBPNameBuffer, &addr);
}
inline OTByteCount NBPAddress::Init(const char* name)
{
fAddressType = AF_ATALK_NBP;
return sizeof(OTAddressType) + OTSetAddressFromNBPString(fNBPNameBuffer, name, -1);
}
inline OTByteCount NBPAddress::Init(const char* name, OTByteCount len)
{
fAddressType = AF_ATALK_NBP;
return sizeof(OTAddressType) + OTSetAddressFromNBPString(fNBPNameBuffer, name, (SInt32)len);
}
inline Boolean NBPAddress::ExtractEntity(NBPEntity& entity, OTByteCount len)
{
return OTSetNBPEntityFromAddress(&entity, fNBPNameBuffer, len);
}
inline OTAddressType NBPAddress::GetAddressType() const
{
return fAddressType;
}
// Inline methods for DDPNBPAddress
inline Boolean DDPNBPAddress::operator==(const DDPAddress& addr) const
{
return OTCompareDDPAddresses((const DDPAddress*)this, &addr);
}
inline void DDPNBPAddress::SetSocket(UInt8 socket)
{
fSocket = socket;
}
inline void DDPNBPAddress::SetNode(UInt8 node)
{
fNodeID = node;
}
inline void DDPNBPAddress::SetType(UInt8 type)
{
fDDPType = type;
}
inline void DDPNBPAddress::SetNetwork(UInt16 net)
{
fNetwork = net;
}
inline OTAddressType DDPNBPAddress::GetAddressType() const
{
return fAddressType;
}
inline UInt8 DDPNBPAddress::GetSocket() const
{
return fSocket;
}
inline UInt8 DDPNBPAddress::GetNode() const
{
return fNodeID;
}
inline UInt8 DDPNBPAddress::GetType() const
{
return fDDPType;
}
inline UInt16 DDPNBPAddress::GetNetwork() const
{
return fNetwork;
}
inline void DDPNBPAddress::Init(UInt16 net, UInt8 node,
UInt8 socket)
{
fAddressType = AF_ATALK_DDPNBP;
SetNetwork(net);
SetNode(node);
SetSocket(socket);
SetType(0);
}
inline void DDPNBPAddress::Init(UInt16 net, UInt8 node,
UInt8 socket, UInt8 type)
{
fAddressType = AF_ATALK_DDPNBP;
SetNetwork(net);
SetNode(node);
SetSocket(socket);
SetType(type);
}
inline void DDPNBPAddress::Init(const DDPAddress& addr)
{
fAddressType = AF_ATALK_DDPNBP;
SetNetwork(addr.GetNetwork());
SetNode(addr.GetNode());
SetSocket(addr.GetSocket());
SetType(addr.GetType());
fNBPNameBuffer[0] = 0;
}
inline OTByteCount DDPNBPAddress::SetNBPEntity(const NBPEntity& entity)
{
return OTSetAddressFromNBPEntity(fNBPNameBuffer, &entity) + kDDPAddressLength;
}
inline OTByteCount DDPNBPAddress::SetNBPEntity(const char* name)
{
return OTSetAddressFromNBPString(fNBPNameBuffer, name, -1) + kDDPAddressLength;
}
inline OTByteCount DDPNBPAddress::SetNBPEntity(const char* name, OTByteCount len)
{
return OTSetAddressFromNBPString(fNBPNameBuffer, name, (SInt32)len) + kDDPAddressLength;
}
inline Boolean DDPNBPAddress::ExtractEntity(NBPEntity& entity, OTByteCount len)
{
return OTSetNBPEntityFromAddress(&entity, fNBPNameBuffer, len);
}
endif /* __cplusplus */
/* AppleTalkInfo as used by the OTGetATalkInfo function*/
struct AppleTalkInfo {
DDPAddress fOurAddress; /* Our DDP address (network # & node)*/
DDPAddress fRouterAddress; /* The address of a router on our cable*/
UInt16 fCableRange[2]; /* The current cable range*/
UInt16 fFlags; /* See below*/
};
typedef struct AppleTalkInfo AppleTalkInfo;
/* For the fFlags field in AppleTalkInfo*/
enum {
kATalkInfoIsExtended = 0x0001, /* This is an extended (phase 2) network*/
kATalkInfoHasRouter = 0x0002, /* This cable has a router*/
kATalkInfoOneZone = 0x0004 /* This cable has only one zone*/
};
/* ***** Ethernet ******/
/* Interface option flags*/
/* Ethernet framing options*/
enum {
kOTFramingEthernet = 0x01,
kOTFramingEthernetIPX = 0x02,
kOTFraming8023 = 0x04,
kOTFraming8022 = 0x08
};
/*
These are obsolete and will be going away in OT 1.5.
Hmmm, OT 1.5 got cancelled. The status of these options
is uncertain.
*/
/* RawMode options*/
enum {
kOTRawRcvOn = 0,
kOTRawRcvOff = 1,
kOTRawRcvOnWithTimeStamp = 2
};
enum {
DL_PROMISC_OFF = 0 /* OPT_SETPROMISCUOUS value*/
};
/* Module definitions*/
/* Module IDs*/
enum {
kT8022ModuleID = 7100,
kEnetModuleID = 7101,
kTokenRingModuleID = 7102,
kFDDIModuleID = 7103
};
/* Module Names*/
define kEnet8022Name "enet8022x"
define kEnetName "enet"
define kFastEnetName "fenet"
define kTokenRingName "tokn"
define kFDDIName "fddi"
define kIRTalkName "irtlk"
define kSMDSName "smds"
define kATMName "atm"
define kT8022Name "tpi8022x"
define kATMSNAPName "atmsnap"
define kFireWireName "firewire"
define kFibreChannelName "fibre"
/* Address Family*/
enum {
AF_8022 = 8200 /* Our 802.2 generic address family*/
};
/* XTI Levels*/
enum {
LNK_ENET = FOUR_CHAR_CODE('ENET'),
LNK_TOKN = FOUR_CHAR_CODE('TOKN'),
LNK_FDDI = FOUR_CHAR_CODE('FDDI'),
LNK_TPI = FOUR_CHAR_CODE('LTPI')
};
/* Options*/
enum {
OPT_ADDMCAST = 0x1000,
OPT_DELMCAST = 0x1001,
OPT_RCVPACKETTYPE = 0x1002,
OPT_RCVDESTADDR = 0x1003,
OPT_SETRAWMODE = 0x1004,
OPT_SETPROMISCUOUS = 0x1005
};
typedef UInt32 OTPacketType;
enum {
kETypeStandard = 0,
kETypeMulticast = 1,
kETypeBroadcast = 2,
kETRawPacketBit = (unsigned long)0x80000000,
kETTimeStampBit = 0x40000000
};
/* Link related constants*/
enum {
kMulticastLength = 6, /* length of an ENET hardware addressaddress*/
k48BitAddrLength = 6,
k8022DLSAPLength = 2, /* The protocol type is our DLSAP*/
k8022SNAPLength = 5,
kEnetAddressLength = k48BitAddrLength + k8022DLSAPLength, /* length of an address field used by the ENET enpoint*/
/* = k48BitAddrLength + sizeof(protocol type)*/
kSNAPSAP = 0x00AA, /* Special DLSAPS for ENET*/
kIPXSAP = 0x00FF,
kMax8022SAP = 0x00FE,
k8022GlobalSAP = 0x00FF,
kMinDIXSAP = 1501,
kMaxDIXSAP = 0xFFFF
};
/* Generic Address Structure*/
struct T8022Address {
OTAddressType fAddrFamily;
UInt8 fHWAddr[6];
UInt16 fSAP;
UInt8 fSNAP[5];
};
typedef struct T8022Address T8022Address;
enum {
k8022BasicAddressLength = sizeof(OTAddressType) + k48BitAddrLength + sizeof(UInt16),
k8022SNAPAddressLength = sizeof(OTAddressType) + k48BitAddrLength + sizeof(UInt16) + k8022SNAPLength
};
/* Some helpful stuff for dealing with 48 bit addresses*/
define OTCompare48BitAddresses(p1, p2) \
(*(const UInt32*)((const UInt8*)(p1)) == *(const UInt32*)((const UInt8*)(p2)) && \
*(const UInt16*)(((const UInt8*)(p1))+4) == *(const UInt16*)(((const UInt8*)(p2))+4) )
define OTCopy48BitAddress(p1, p2) \
(*(UInt32*)((UInt8*)(p2)) = *(const UInt32*)((const UInt8*)(p1)), \
*(UInt16*)(((UInt8*)(p2))+4) = *(const UInt16*)(((const UInt8*)(p1))+4) )
define OTClear48BitAddress(p1) \
(*(UInt32*)((UInt8*)(p1)) = 0, \
*(UInt16*)(((UInt8*)(p1))+4) = 0 )
define OTCompare8022SNAP(p1, p2) \
(*(const UInt32*)((const UInt8*)(p1)) == *(const UInt32*)((const UInt8*)(p2)) && \
*(((const UInt8*)(p1))+4) == *(((const UInt8*)(p2))+4) )
define OTCopy8022SNAP(p1, p2) \
(*(UInt32*)((UInt8*)(p2)) = *(const UInt32*)((const UInt8*)(p1)), \
*(((UInt8*)(p2))+4) = *(((const UInt8*)(p1))+4) )
define OTIs48BitBroadcastAddress(p1) \
(*(UInt32*)((UInt8*)(p1)) == 0xffffffff && \
*(UInt16*)(((UInt8*)(p1))+4) == 0xffff )
define OTSet48BitBroadcastAddress(p1) \
(*(UInt32*)((UInt8*)(p1)) = 0xffffffff, \
*(UInt16*)(((UInt8*)(p1))+4) = 0xffff )
define OTIs48BitZeroAddress(p1) \
(*(UInt32*)((UInt8*)(p1)) == 0 && \
*(UInt16*)(((UInt8*)(p1))+4) == 0 )
/* Link related constants*/
enum {
kEnetPacketHeaderLength = (2 * k48BitAddrLength) + k8022DLSAPLength,
kEnetTSDU = 1514, /* The TSDU for ethernet.*/
kTokenRingTSDU = 4458, /* The TSDU for TokenRing.*/
kFDDITSDU = 4458, /* The TSDU for FDDI. */
k8022SAPLength = 1,
k8022BasicHeaderLength = 3, /* define the length of the header portion of an 802.2 packet.*/
/* = SSAP+DSAP+ControlByte*/
k8022SNAPHeaderLength = k8022SNAPLength + k8022BasicHeaderLength
};
*****************************************************************************
* Address Types recognized by the Enet DLPI
******************************************************************************
typedef UInt32 EAddrType;
enum {
keaStandardAddress = 0,
keaMulticast = 1,
keaBroadcast = 2,
keaBadAddress = 3,
keaRawPacketBit = (unsigned long)0x80000000,
keaTimeStampBit = 0x40000000
};
/* Packet Header Structures*/
struct EnetPacketHeader {
UInt8 fDestAddr[6];
UInt8 fSourceAddr[6];
UInt16 fProto;
};
typedef struct EnetPacketHeader EnetPacketHeader;
struct T8022Header {
UInt8 fDSAP;
UInt8 fSSAP;
UInt8 fCtrl;
};
typedef struct T8022Header T8022Header;
struct T8022SNAPHeader {
UInt8 fDSAP;
UInt8 fSSAP;
UInt8 fCtrl;
UInt8 fSNAP[5];
};
typedef struct T8022SNAPHeader T8022SNAPHeader;
struct T8022FullPacketHeader {
EnetPacketHeader fEnetPart;
T8022SNAPHeader f8022Part;
};
typedef struct T8022FullPacketHeader T8022FullPacketHeader;
/* Define the lengths of the structures above*/
enum {
kT8022HeaderLength = 3,
kT8022SNAPHeaderLength = 3 + k8022SNAPLength,
kT8022FullPacketHeaderLength = kEnetPacketHeaderLength + kT8022SNAPHeaderLength
};
/* ***** Serial ******/
/* Module Definitions*/
/* XTI Level*/
enum {
COM_SERIAL = FOUR_CHAR_CODE('SERL')
};
/* Version Number*/
define kSerialABVersion "1.1.1"
/* Module Names*/
define kSerialABName "serialAB"
define kSerialName "serial"
define kSerialPortAName "serialA"
define kSerialPortBName "serialB"
enum {
kSerialABModuleID = 7200
};
enum {
kOTSerialFramingAsync = 0x01, /* Support Async serial mode */
kOTSerialFramingHDLC = 0x02, /* Support HDLC synchronous serial mode */
kOTSerialFramingSDLC = 0x04, /* Support SDLC synchronous serial mode */
kOTSerialFramingAsyncPackets = 0x08 /* Support Async "packet" serial mode */
};
/* IOCTL Calls for Serial Drivers*/
enum {
I_SetSerialDTR = ((MIOC_SRL << 8) | 0), /* Set DTR (0 = off, 1 = on)*/
kOTSerialSetDTROff = 0,
kOTSerialSetDTROn = 1,
I_SetSerialBreak = ((MIOC_SRL << 8) | 1), /* Send a break on the line - kOTSerialSetBreakOff = off, kOTSerialSetBreakOn = on,*/
/* Any other number is the number of milliseconds to leave break on, then*/
/* auto shutoff*/
kOTSerialSetBreakOn = (unsigned long)0xFFFFFFFF,
kOTSerialSetBreakOff = 0,
I_SetSerialXOffState = ((MIOC_SRL << 8) | 2), /* Force XOFF state - 0 = Unconditionally clear XOFF state, 1 = unconditionally set it*/
kOTSerialForceXOffTrue = 1,
kOTSerialForceXOffFalse = 0,
I_SetSerialXOn = ((MIOC_SRL << 8) | 3), /* Send an XON character, 0 = send only if in XOFF state, 1 = send always*/
kOTSerialSendXOnAlways = 1,
kOTSerialSendXOnIfXOffTrue = 0,
I_SetSerialXOff = ((MIOC_SRL << 8) | 4), /* Send an XOFF character, 0 = send only if in XON state, 1 = send always*/
kOTSerialSendXOffAlways = 1,
kOTSerialSendXOffIfXOnTrue = 0
};
/* Option Management for Serial Drivers*/
/*
These options are all 4-byte values.
BaudRate is the baud rate.
DataBits is the number of data bits.
StopBits is the number of stop bits times 10.
Parity is an enum
*/
enum {
SERIAL_OPT_BAUDRATE = 0x0100, /* UInt32 */
SERIAL_OPT_DATABITS = 0x0101, /* UInt32 */
SERIAL_OPT_STOPBITS = 0x0102, /* UInt32 10, 15 or 20 for 1, 1.5 or 2 */
SERIAL_OPT_PARITY = 0x0103, /* UInt32 */
SERIAL_OPT_STATUS = 0x0104, /* UInt32 */
/* The "Status" option is a 4-byte value option that is ReadOnly*/
/* It returns a bitmap of the current serial status*/
SERIAL_OPT_HANDSHAKE = 0x0105, /* UInt32 */
/* The "Handshake" option defines what kind of handshaking the serial port*/
/* will do for line flow control. The value is a 32-bit value defined by*/
/* the function or macro SerialHandshakeData below.*/
/* For no handshake, or CTS handshake, the onChar and offChar parameters*/
/* are ignored.*/
SERIAL_OPT_RCVTIMEOUT = 0x0106, /* The "RcvTimeout" option defines how long the receiver should wait before delivering*/
/* less than the RcvLoWat number of characters. If RcvLoWat is 0, then the RcvTimeout*/
/* is how long a gap to wait for before delivering characters. This parameter is advisory,*/
/* and serial drivers are free to deliver data whenever they deem it convenient. For instance,*/
/* many serial drivers will deliver data whenever 64 bytes have been received, since 64 bytes*/
/* is the smallest STREAMS buffer size. Keep in mind that timeouts are quantized, so be sure to*/
/* look at the return value of the option to determine what it was negotiated to.*/
SERIAL_OPT_ERRORCHARACTER = 0x0107, /* This option defines how characters with parity errors are handled.*/
/* A 0 value will disable all replacement. A single character value in the low*/
/* byte designates the replacement character. When characters are received with a */
/* parity error, they are replaced by this specified character. If a valid incoming*/
/* character matches the replacement character, then the received character's msb is*/
/* cleared. For this situation, the alternate character is used, if specified in bits*/
/* 8 through 15 of the option long, with 0xff being place in bits 16 through 23.*/
/* Whenever a valid character is received that matches the first replacement character,*/
/* it is replaced with this alternate character.*/
SERIAL_OPT_EXTCLOCK = 0x0108, /* The "ExtClock" requests an external clock. A 0-value turns off external clocking.*/
/* Any other value is a requested divisor for the external clock. Be aware that*/
/* not all serial implementations support an external clock, and that not all*/
/* requested divisors will be supported if it does support an external clock.*/
SERIAL_OPT_BURSTMODE = 0x0109, /* The "BurstMode" option informs the serial driver that it should continue looping,*/
/* reading incoming characters, rather than waiting for an interrupt for each character.*/
/* This option may not be supported by all Serial driver*/
SERIAL_OPT_DUMMY = 0x010A /* placeholder*/
};
typedef UInt32 ParityOptionValues;
enum {
kOTSerialNoParity = 0,
kOTSerialOddParity = 1,
kOTSerialEvenParity = 2
};
enum {
kOTSerialSwOverRunErr = 0x01,
kOTSerialBreakOn = 0x08,
kOTSerialParityErr = 0x10,
kOTSerialOverrunErr = 0x20,
kOTSerialFramingErr = 0x40,
kOTSerialXOffSent = 0x00010000,
kOTSerialDTRNegated = 0x00020000,
kOTSerialCTLHold = 0x00040000,
kOTSerialXOffHold = 0x00080000,
kOTSerialOutputBreakOn = 0x01000000
};
enum {
kOTSerialXOnOffInputHandshake = 1, /* Want XOn/XOff handshake for incoming characters */
kOTSerialXOnOffOutputHandshake = 2, /* Want XOn/XOff handshake for outgoing characters */
kOTSerialCTSInputHandshake = 4, /* Want CTS handshake for incoming characters */
kOTSerialDTROutputHandshake = 8 /* Want DTR handshake for outoing characters */
};
ifdef __cplusplus
inline UInt32 OTSerialHandshakeData(UInt16 type, UInt8 onChar, UInt8 offChar)
{
return (((UInt32)type) << 16) | (((UInt32)onChar) << 8) | offChar;
}
else
#define OTSerialHandshakeData(type, onChar, offChar) \
((((UInt32)type) << 16) | (((UInt32)onChar) << 8) | offChar)
endif
ifdef __cplusplus
inline UInt32 OTSerialSetErrorCharacter(UInt8 rep)
{
return (UInt32)rep & 0x000000ff;
}
inline UInt32 OTSerialSetErrorCharacterWithAlternate(UInt8 rep, UInt8 alternate)
{
return (((rep & 0xff) | ((alternate & 0xff) << 8)) | 0x80000000L);
}
else
define OTSerialSetErrorCharacter(rep) \
((rep) & 0xff)
define OTSerialSetErrorCharacterWithAlternate(rep, alternate) \
((((rep) & 0xff) | (((alternate) & 0xff) << 8)) | 0x80000000L)
endif
/* Default attributes for the serial ports*/
enum {
kOTSerialDefaultBaudRate = 19200,
kOTSerialDefaultDataBits = 8,
kOTSerialDefaultStopBits = 10,
kOTSerialDefaultParity = kOTSerialNoParity,
kOTSerialDefaultHandshake = 0,
kOTSerialDefaultOnChar = ('Q' & 0xFFFFFFBF),
kOTSerialDefaultOffChar = ('S' & 0xFFFFFFBF),
kOTSerialDefaultSndBufSize = 1024,
kOTSerialDefaultRcvBufSize = 1024,
kOTSerialDefaultSndLoWat = 96,
kOTSerialDefaultRcvLoWat = 1,
kOTSerialDefaultRcvTimeout = 10
};
/* ***** ISDN ******/
/* Module Definitions*/
/* XTI Level*/
enum {
COM_ISDN = FOUR_CHAR_CODE('ISDN')
};
/* Module Names*/
define kISDNName "isdn"
enum {
kISDNModuleID = 7300
};
/* ISDN framing methods, set using the I_OTSetFramingType IOCTL*/
enum {
kOTISDNFramingTransparentSupported = 0x0010, /* Support Transparent mode */
kOTISDNFramingHDLCSupported = 0x0020, /* Support HDLC Synchronous mode */
kOTISDNFramingV110Supported = 0x0040, /* Support V.110 Asynchronous mode */
kOTISDNFramingV14ESupported = 0x0080 /* Support V.14 Asynchronous mode */
};
/* Miscellaneous equates*/
/* Disconnect reason codes (from Q.931)*/
enum {
kOTISDNUnallocatedNumber = 1,
kOTISDNNoRouteToSpecifiedTransitNetwork = 2,
kOTISDNNoRouteToDestination = 3,
kOTISDNChannelUnacceptable = 6,
kOTISDNNormal = 16,
kOTISDNUserBusy = 17,
kOTISDNNoUserResponding = 18,
kOTISDNNoAnswerFromUser = 19,
kOTISDNCallRejected = 21,
kOTISDNNumberChanged = 22,
kOTISDNNonSelectedUserClearing = 26,
kOTISDNDestinationOutOfOrder = 27,
kOTISDNInvalidNumberFormat = 28,
kOTISDNFacilityRejected = 29,
kOTISDNNormalUnspecified = 31,
kOTISDNNoCircuitChannelAvailable = 34,
kOTISDNNetworkOutOfOrder = 41,
kOTISDNSwitchingEquipmentCongestion = 42,
kOTISDNAccessInformationDiscarded = 43,
kOTISDNRequestedCircuitChannelNotAvailable = 44,
kOTISDNResourceUnavailableUnspecified = 45,
kOTISDNQualityOfServiceUnvailable = 49,
kOTISDNRequestedFacilityNotSubscribed = 50,
kOTISDNBearerCapabilityNotAuthorized = 57,
kOTISDNBearerCapabilityNotPresentlyAvailable = 58,
kOTISDNCallRestricted = 59,
kOTISDNServiceOrOptionNotAvilableUnspecified = 63,
kOTISDNBearerCapabilityNotImplemented = 65,
kOTISDNRequestedFacilityNotImplemented = 69,
kOTISDNOnlyRestrictedDigitalBearer = 70,
kOTISDNServiceOrOptionNotImplementedUnspecified = 79,
kOTISDNCallIdentityNotUsed = 83,
kOTISDNCallIdentityInUse = 84,
kOTISDNNoCallSuspended = 85,
kOTISDNCallIdentityCleared = 86,
kOTISDNIncompatibleDestination = 88,
kOTISDNInvalidTransitNetworkSelection = 91,
kOTISDNInvalidMessageUnspecified = 95,
kOTISDNMandatoryInformationElementIsMissing = 96,
kOTISDNMessageTypeNonExistentOrNotImplemented = 97,
kOTISDNInterworkingUnspecified = 127
};
/* OTISDNAddress*/
/*
The OTISDNAddress has the following format:
"xxxxxx*yy"
where 'x' is the phone number and 'y' is the sub address (if available
in the network. The characters are coded in ASCII (IA5), and valid
characters are: '0'-'9','#','*'.
The max length of the each phone number is 21 characters (?) and the max
subaddress length is network dependent.
When using bonded channels the phone numbers are separated by '&'.
The X.25 user data is preceded by '@'.
*/
ifndef AF_ISDN /* might conflict with BSD headers */
enum {
AF_ISDN = 0x2000
};
endif
enum {
kOTISDNMaxPhoneSize = 32,
kOTISDNMaxSubSize = 4
};
struct OTISDNAddress {
OTAddressType fAddressType;
UInt16 fPhoneLength;
char fPhoneNumber[37];
};
typedef struct OTISDNAddress OTISDNAddress;
/* IOCTL Calls for ISDN*/
/* ISDN shares the same ioctl space as serial.*/
enum {
MIOC_ISDN = 'U' /* ISDN ioctl() cmds */
};
enum {
I_OTISDNAlerting = ((MIOC_ISDN << 8) | 100), /* Send or receive an ALERTING message*/
I_OTISDNSuspend = ((MIOC_ISDN << 8) | 101), /* Send a SUSPEND message*/
/* The parameter is the Call Identity (Maximum 8 octets)*/
I_OTISDNSuspendAcknowledge = ((MIOC_ISDN << 8) | 102), /* Receive a SUSPEND ACKNOWLEDGE message*/
I_OTISDNSuspendReject = ((MIOC_ISDN << 8) | 103), /* Receive a SUSPEND REJECT message*/
I_OTISDNResume = ((MIOC_ISDN << 8) | 104), /* Send a RESUME message*/
/* The parameter is the Call Identity (Maximum 8 octets)*/
I_OTISDNResumeAcknowledge = ((MIOC_ISDN << 8) | 105), /* Receive a RESUME ACKNOWLEDGE message*/
I_OTISDNResumeReject = ((MIOC_ISDN << 8) | 106), /* Receive a RESUME REJECT message*/
I_OTISDNFaciltity = ((MIOC_ISDN << 8) | 107) /* Send or receive a FACILITY message*/
};
/* Connect user data size*/
enum {
kOTISDNMaxUserDataSize = 32
};
/* Option management calls for ISDN*/
enum {
ISDN_OPT_COMMTYPE = 0x0200,
ISDN_OPT_FRAMINGTYPE = 0x0201,
ISDN_OPT_56KADAPTATION = 0x0202
};
/* For ISDN_OPT_COMMTYPE...*/
enum {
kOTISDNTelephoneALaw = 1, /* G.711 A-law */
kOTISDNTelephoneMuLaw = 26, /* G.711 .-law */
kOTISDNDigital64k = 13, /* unrestricted digital (default) */
kOTISDNDigital56k = 37, /* user rate 56Kb/s */
kOTISDNVideo64k = 41, /* video terminal at 64Kb/s */
kOTISDNVideo56k = 42 /* video terminal at 56Kb/s */
};
/* For ISDN_OPT_FRAMINGTYPE...*/
enum {
kOTISDNFramingTransparent = 0x0010, /* Transparent mode */
kOTISDNFramingHDLC = 0x0020, /* HDLC synchronous mode (default) */
kOTISDNFramingV110 = 0x0040, /* V.110 asynchronous mode */
kOTISDNFramingV14E = 0x0080 /* V.14E asynchronous mode */
};
/* For ISDN_OPT_56KADAPTATION...*/
enum {
kOTISDNNot56KAdaptation = false, /* not 56K Adaptation (default) */
kOTISDN56KAdaptation = true /* 56K Adaptation */
};
/* Default options, you do not need to set these*/
enum {
kOTISDNDefaultCommType = kOTISDNDigital64k,
kOTISDNDefaultFramingType = kOTISDNFramingHDLC,
kOTISDNDefault56KAdaptation = kOTISDNNot56KAdaptation
};
if defined(__MWERKS__) && TARGET_CPU_68K
#pragma pop
endif
if PRAGMA_STRUCT_ALIGN
#pragma options align=reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
endif
ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
endif
ifdef __cplusplus
}
endif
endif /* __OPENTRANSPORTPROVIDERS__ */
(C) Æliens
04/09/2009
You may not copy or print any of this material without explicit permission of the author or the publisher.
In case of other copyright issues, contact the author.
