OpenTransportProviders.h

Go to the documentation of this file.

 
#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
 
  typedef UInt16 InetPort;
  typedef UInt32 InetHost;
#define AF_INET 2
  enum
  {
    AF_DNS = 42
  };
 
  enum
  {
    kOTAnyInetAddress = 0 
  };
 
#ifdef __cplusplus
  typedef class TInternetServices *InetSvcRef;
#else
typedef void *InetSvcRef;
#endif
#define kDefaultInternetServicesPath ((OTConfigurationRef)-3L)
#define kInetVersion "3.1.1"
#define kInetPrefix "ot:inet$"
 
#define kDNRName "dnr"
#define kTCPName "tcp"
#define kUDPName "udp"
#define kRawIPName "rawip"
 
  enum
  {
    INET_IP = 0x00,
    INET_TCP = 0x06,
    INET_UDP = 0x11
  };
 
  enum
  {
    TCP_NODELAY = 0x01,
    TCP_MAXSEG = 0x02,
    TCP_NOTIFY_THRESHOLD = 0x10,      /*** 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            
  };
 
  enum
  {
    T_GARBAGE = 2
  };
 
  enum
  {
    UDP_CHECKSUM = 0x0600,
    UDP_RX_ICMP = 0x02
  };
 
  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,     
    kIP_MULTICAST_TTL = 0x1011,    
    kIP_MULTICAST_LOOP = 0x1012,   
    kIP_ADD_MEMBERSHIP = 0x1013,   
    kIP_DROP_MEMBERSHIP = 0x1014,  
    kIP_BROADCAST_IFNAME = 0x1015, 
    kIP_RCVIFADDR = 0x1016         
  };
 
  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,       
    IP_MULTICAST_TTL = kIP_MULTICAST_TTL,     
    IP_MULTICAST_LOOP = kIP_MULTICAST_LOOP,   
    IP_ADD_MEMBERSHIP = kIP_ADD_MEMBERSHIP,   
    IP_DROP_MEMBERSHIP = kIP_DROP_MEMBERSHIP, 
    IP_BROADCAST_IFNAME =
        kIP_BROADCAST_IFNAME,    
    IP_RCVIFADDR = kIP_RCVIFADDR 
  };
 
  enum
  {
    DVMRP_INIT = 100, 
    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
  };
 
  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
  };
 
  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)))
  struct TIPAddMulticast
  {
    InetHost multicastGroupAddress;
    InetHost interfaceAddress;
  };
  typedef struct TIPAddMulticast TIPAddMulticast;
  enum
  {
    T_DNRSTRINGTOADDRCOMPLETE = kPRIVATEEVENT + 1,
    T_DNRADDRTONAMECOMPLETE = kPRIVATEEVENT + 2,
    T_DNRSYSINFOCOMPLETE = kPRIVATEEVENT + 3,
    T_DNRMAILEXCHANGECOMPLETE = kPRIVATEEVENT + 4,
    T_DNRQUERYCOMPLETE = kPRIVATEEVENT + 5
  };
 
  struct InetAddress
  {
    OTAddressType fAddressType; 
    InetPort fPort;             
    InetHost fHost;             
    UInt8 fUnused[8];           
  };
  typedef struct InetAddress InetAddress;
  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;  
    UInt16 resourceLen;   
    char resourceData[4]; 
  };
  typedef struct DNSQueryInfo DNSQueryInfo;
  struct DNSAddress
  {
    OTAddressType fAddressType; 
    InetDomainName fName;
  };
  typedef struct DNSAddress DNSAddress;
  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;
  enum
  {
    kAllDHCPOptions = -1,
    kDHCPLongOption = 126,
    kDHCPLongOptionReq = 127
  };
 
  struct InetDHCPOption
  {
    UInt8 fOptionTag;
    UInt8 fOptionLen;
    UInt8 fOptionValue;
  };
  typedef struct InetDHCPOption InetDHCPOption;
  void
  OTInitInetAddress(InetAddress *addr, InetPort port, InetHost host);
 
  OTByteCount
  OTInitDNSAddress(DNSAddress *addr, char *str);
 
  OSStatus
  OTInetStringToHost(const char *str, InetHost *host);
 
  void
  OTInetHostToString(InetHost host, char *str);
 
  OSStatus
  OTInetGetInterfaceInfo(InetInterfaceInfo *info, SInt32 val);
 
  OSStatus
  OTInetGetSecondaryAddresses(InetHost *addr, UInt32 *count, SInt32 val);
 
#if CALL_NOT_IN_CARBON
  OSStatus
  OTInetGetDHCPConfigInfo(InetDHCPOption *buf, UInt32 bufSize, SInt32 index,
                          SInt32 opt);
 
#endif 
#if !OTKERNEL
  InetSvcRef
  OTOpenInternetServicesInContext(OTConfigurationRef cfig, OTOpenFlags oflag,
                                  OSStatus *err,
                                  OTClientContextPtr clientContext);
 
  OSStatus
  OTAsyncOpenInternetServicesInContext(OTConfigurationRef cfig, OTOpenFlags oflag,
                                       OTNotifyUPP upp, void *contextPtr,
                                       OTClientContextPtr clientContext);
 
#if CALL_NOT_IN_CARBON
  InetSvcRef
  OTOpenInternetServices(OTConfigurationRef cfig, OTOpenFlags oflag,
                         OSStatus *err);
 
  OSStatus
  OTAsyncOpenInternetServices(OTConfigurationRef cfig, OTOpenFlags oflag,
                              OTNotifyUPP proc, void *contextPtr);
 
#endif 
#if OTCARBONAPPLICATION
#define OTOpenInternetServices(cfig, oflags, err) \
  OTOpenInternetServicesInContext(cfig, oflags, err, NULL)
#define OTAsyncOpenInternetServices(cfig, oflags, proc, contextPtr) \
  OTAsyncOpenInternetServicesInContext(cfig, oflags, proc, contextPtr, NULL)
#endif 
  OSStatus
  OTInetStringToAddress(InetSvcRef ref, char *name, InetHostInfo *hinfo);
 
  OSStatus
  OTInetAddressToName(InetSvcRef ref, InetHost addr, InetDomainName name);
 
  OSStatus
  OTInetSysInfo(InetSvcRef ref, char *name, InetSysInfo *sysinfo);
 
  OSStatus
  OTInetMailExchange(InetSvcRef ref, char *name, UInt16 *num,
                     InetMailExchange *mx);
 
  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"
{ 
#endif
#endif 
#define kATalkVersion "1.1"
#define kATalkPrefix "ot:atlk$"
#define kATBinderID "ot:atbd$"
 
  /********************************************************************************
  ** Module definitions
  ********************************************************************************/
  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 ')
  };
 
#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"
 
  enum
  {
    DDP_OPT_CHECKSUM = 0x0600,
    DDP_OPT_SRCADDR =
        0x2101,                
    ATP_OPT_REPLYCNT = 0x2110, 
    ATP_OPT_DATALEN = 0x2111,  
    ATP_OPT_RELTIMER =
        0x2112, 
    ATP_OPT_TRANID =
        0x2113,                
    PAP_OPT_OPENRETRY = 0x2120 
  };
 
  enum
  {
    kAppleTalkEvent = kPROTOCOLEVENT | 0x00010000,
    T_GETMYZONECOMPLETE = kAppleTalkEvent + 1,
    T_GETLOCALZONESCOMPLETE = kAppleTalkEvent + 2,
    T_GETZONELISTCOMPLETE = kAppleTalkEvent + 3,
    T_GETATALKINFOCOMPLETE = kAppleTalkEvent + 4,
    T_ATALKROUTERDOWNEVENT =
        kAppleTalkEvent +
        51, 
    T_ATALKROUTERUPEVENT =
        kAppleTalkEvent + 52, 
    T_ATALKZONENAMECHANGEDEVENT =
        kAppleTalkEvent + 53, 
    T_ATALKCONNECTIVITYCHANGEDEVENT =
        kAppleTalkEvent + 54, 
    T_ATALKINTERNETAVAILABLEEVENT =
        kAppleTalkEvent +
        55, 
    T_ATALKCABLERANGECHANGEDEVENT =
        kAppleTalkEvent +
        56 
  };
 
  enum
  {
    kAllATalkRoutersDown = 0,     
    kLocalATalkRoutersDown = -1L, 
    kARARouterDisconnected =
        -2L 
  };
 
  enum
  {
    kARARouterOnline =
        -1L, 
    kATalkRouterOnline =
        0, 
    kLocalATalkRouterOnline =
        -2L 
  };
 
#define IsAppleTalkEvent(x)         ((x) & 0xffff0000) == kAppleTalkEvent)
  enum
  {
    ATALK_IOC_FULLSELFSEND =
        ((MIOC_ATALK << 8) | 47),                    
    ADSP_IOC_FORWARDRESET = ((MIOC_ATALK << 8) | 60) 
  };
 
  enum
  {
    kECHO_TSDU = 585 
  };
 
  enum
  {
    kNBPMaxNameLength = 32,
    kNBPMaxTypeLength = 32,
    kNBPMaxZoneLength = 32,
    kNBPSlushLength = 9, 
    kNBPMaxEntityLength =
        (kNBPMaxNameLength + kNBPMaxTypeLength + kNBPMaxZoneLength + 3),
    kNBPEntityBufferSize = (kNBPMaxNameLength + kNBPMaxTypeLength +
                            kNBPMaxZoneLength + kNBPSlushLength),
    kNBPWildCard = 0x3D,         
    kNBPImbeddedWildCard = 0xC5, 
    kNBPDefaultZone = 0x2A       
  };
 
  enum
  {
    kZIPMaxZoneLength = kNBPMaxZoneLength
  };
 
  enum
  {
    kDDPAddressLength = 8, 
    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
#ifdef __cplusplus
  typedef class TAppleTalkServices *ATSvcRef;
#else
  typedef void *ATSvcRef;
#endif
#define kDefaultAppleTalkServicesPath ((OTConfigurationRef)-3L)
  OSStatus
  OTAsyncOpenAppleTalkServicesInContext(OTConfigurationRef cfig,
                                        OTOpenFlags flags, OTNotifyUPP proc,
                                        void *contextPtr,
                                        OTClientContextPtr clientContext);
 
  ATSvcRef
  OTOpenAppleTalkServicesInContext(OTConfigurationRef cfig, OTOpenFlags flags,
                                   OSStatus *err,
                                   OTClientContextPtr clientContext);
 
#if CALL_NOT_IN_CARBON
  OSStatus
  OTAsyncOpenAppleTalkServices(OTConfigurationRef cfig, OTOpenFlags flags,
                               OTNotifyUPP proc, void *contextPtr);
 
  ATSvcRef
  OTOpenAppleTalkServices(OTConfigurationRef cfig, OTOpenFlags flags,
                          OSStatus *err);
 
#endif 
#if OTCARBONAPPLICATION
#define OTOpenAppleTalkServices(cfig, oflags, err) \
  OTOpenAppleTalkServicesInContext(cfig, oflags, err, NULL)
#define OTAsyncOpenAppleTalkServices(cfig, oflags, proc, contextPtr) \
  OTAsyncOpenAppleTalkServicesInContext(cfig, oflags, proc, contextPtr, NULL)
#endif 
  OSStatus
  OTATalkGetMyZone(ATSvcRef ref, TNetbuf *zone);
 
  OSStatus
  OTATalkGetLocalZones(ATSvcRef ref, TNetbuf *zones);
 
  OSStatus
  OTATalkGetZoneList(ATSvcRef ref, TNetbuf *zones);
 
  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"
{      
#endif 
#endif 
  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; 
    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; 
    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; 
    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;
  void
  OTInitDDPAddress(DDPAddress *addr, UInt16 net, UInt8 node, UInt8 socket,
                   UInt8 ddpType);
 
  OTByteCount
  OTInitNBPAddress(NBPAddress *addr, const char *name);
 
  OTByteCount
  OTInitDDPNBPAddress(DDPNBPAddress *addr, const char *name, UInt16 net,
                      UInt8 node, UInt8 socket, UInt8 ddpType);
 
  Boolean
  OTCompareDDPAddresses(const DDPAddress *addr1, const DDPAddress *addr2);
 
  void
  OTInitNBPEntity(NBPEntity *entity);
 
  OTByteCount
  OTGetNBPEntityLengthAsAddress(const NBPEntity *entity);
 
  OTByteCount
  OTSetAddressFromNBPEntity(UInt8 *nameBuf, const NBPEntity *entity);
 
  OTByteCount
  OTSetAddressFromNBPString(UInt8 *addrBuf, const char *name, SInt32 len);
 
  Boolean
  OTSetNBPEntityFromAddress(NBPEntity *entity, const UInt8 *addrBuf,
                            OTByteCount len);
 
  Boolean
  OTSetNBPName(NBPEntity *entity, const char *name);
 
  Boolean
  OTSetNBPType(NBPEntity *entity, const char *typeVal);
 
  Boolean
  OTSetNBPZone(NBPEntity *entity, const char *zone);
 
  void
  OTExtractNBPName(const NBPEntity *entity, char *name);
 
  void
  OTExtractNBPType(const NBPEntity *entity, char *typeVal);
 
  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 
  struct AppleTalkInfo
  {
    DDPAddress fOurAddress;    
    DDPAddress fRouterAddress; 
    UInt16 fCableRange[2];     
    UInt16 fFlags;             
  };
  typedef struct AppleTalkInfo AppleTalkInfo;
  enum
  {
    kATalkInfoIsExtended = 0x0001, 
    kATalkInfoHasRouter = 0x0002,  
    kATalkInfoOneZone = 0x0004     
  };
 
  enum
  {
    kOTFramingEthernet = 0x01,
    kOTFramingEthernetIPX = 0x02,
    kOTFraming8023 = 0x04,
    kOTFraming8022 = 0x08
  };
 
  enum
  {
    kOTRawRcvOn = 0,
    kOTRawRcvOff = 1,
    kOTRawRcvOnWithTimeStamp = 2
  };
 
  enum
  {
    DL_PROMISC_OFF = 0 
  };
 
  enum
  {
    kT8022ModuleID = 7100,
    kEnetModuleID = 7101,
    kTokenRingModuleID = 7102,
    kFDDIModuleID = 7103
  };
 
#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"
 
  enum
  {
    AF_8022 = 8200 
  };
 
  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')
  };
 
  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
  };
 
  enum
  {
    kMulticastLength = 6, 
    k48BitAddrLength = 6,
    k8022DLSAPLength = 2, 
    k8022SNAPLength = 5,
    kEnetAddressLength =
        k48BitAddrLength + k8022DLSAPLength, 
    kSNAPSAP = 0x00AA, 
    kIPXSAP = 0x00FF,
    kMax8022SAP = 0x00FE,
    k8022GlobalSAP = 0x00FF,
    kMinDIXSAP = 1501,
    kMaxDIXSAP = 0xFFFF
  };
 
  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
  };
 
#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)
 
  enum
  {
    kEnetPacketHeaderLength = (2 * k48BitAddrLength) + k8022DLSAPLength,
    kEnetTSDU = 1514,      
    kTokenRingTSDU = 4458, 
    kFDDITSDU = 4458,      
    k8022SAPLength = 1,
    k8022BasicHeaderLength =
        3, 
    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
  };
 
  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;
  enum
  {
    kT8022HeaderLength = 3,
    kT8022SNAPHeaderLength = 3 + k8022SNAPLength,
    kT8022FullPacketHeaderLength =
        kEnetPacketHeaderLength + kT8022SNAPHeaderLength
  };
 
  enum
  {
    COM_SERIAL = FOUR_CHAR_CODE('SERL')
  };
 
#define kSerialABVersion "1.1.1"
 
#define kSerialABName "serialAB"
#define kSerialName "serial"
#define kSerialPortAName "serialA"
#define kSerialPortBName "serialB"
 
  enum
  {
    kSerialABModuleID = 7200
  };
 
  enum
  {
    kOTSerialFramingAsync = 0x01,        
    kOTSerialFramingHDLC = 0x02,         
    kOTSerialFramingSDLC = 0x04,         
    kOTSerialFramingAsyncPackets = 0x08, 
    kOTSerialFramingPPP = 0x10           
  };
 
  enum
  {
    I_SetSerialDTR = ((MIOC_SRL << 8) | 0), 
    kOTSerialSetDTROff = 0,
    kOTSerialSetDTROn = 1,
    I_SetSerialBreak =
        ((MIOC_SRL << 8) | 1), 
    kOTSerialSetBreakOn = (unsigned long)0xFFFFFFFF,
    kOTSerialSetBreakOff = 0,
    I_SetSerialXOffState =
        ((MIOC_SRL << 8) | 2), 
    kOTSerialForceXOffTrue = 1,
    kOTSerialForceXOffFalse = 0,
    I_SetSerialXOn =
        ((MIOC_SRL << 8) | 3), 
    kOTSerialSendXOnAlways = 1,
    kOTSerialSendXOnIfXOffTrue = 0,
    I_SetSerialXOff =
        ((MIOC_SRL << 8) | 4), 
    kOTSerialSendXOffAlways = 1,
    kOTSerialSendXOffIfXOnTrue = 0
  };
 
  enum
  {
    SERIAL_OPT_BAUDRATE = 0x0100, 
    SERIAL_OPT_DATABITS = 0x0101, 
    SERIAL_OPT_STOPBITS = 0x0102, 
    SERIAL_OPT_PARITY = 0x0103,   
    SERIAL_OPT_STATUS = 0x0104,   
    SERIAL_OPT_HANDSHAKE = 0x0105, 
    SERIAL_OPT_RCVTIMEOUT =
        0x0106, 
    SERIAL_OPT_ERRORCHARACTER = 0x0107, 
    SERIAL_OPT_EXTCLOCK = 0x0108, 
    SERIAL_OPT_BURSTMODE = 0x0109, 
    SERIAL_OPT_DUMMY = 0x010A 
  };
 
  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, 
    kOTSerialXOnOffOutputHandshake =
        2, 
    kOTSerialCTSInputHandshake =
        4, 
    kOTSerialDTROutputHandshake =
        8 
  };
 
#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
 
  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
  };
 
  enum
  {
    COM_ISDN = FOUR_CHAR_CODE('ISDN')
  };
 
#define kISDNName "isdn"
  enum
  {
    kISDNModuleID = 7300
  };
 
  enum
  {
    kOTISDNFramingTransparentSupported = 0x0010, 
    kOTISDNFramingHDLCSupported = 0x0020,        
    kOTISDNFramingV110Supported = 0x0040,        
    kOTISDNFramingV14ESupported = 0x0080         
  };
 
  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
  };
 
  enum
  {
    kAF_ISDN = 0x2000
  };
 
  enum
  {
    AF_ISDN = kAF_ISDN
  };
 
  enum
  {
    kOTISDNMaxPhoneSize = 32,
    kOTISDNMaxSubSize = 4
  };
 
  struct OTISDNAddress
  {
    OTAddressType fAddressType;
    UInt16 fPhoneLength;
    char fPhoneNumber[37];
  };
  typedef struct OTISDNAddress OTISDNAddress;
  enum
  {
    MIOC_ISDN = 'U' 
  };
 
  enum
  {
    I_OTISDNAlerting =
        ((MIOC_ISDN << 8) | 100),               
    I_OTISDNSuspend = ((MIOC_ISDN << 8) | 101), 
    I_OTISDNSuspendAcknowledge =
        ((MIOC_ISDN << 8) | 102), 
    I_OTISDNSuspendReject =
        ((MIOC_ISDN << 8) | 103),              
    I_OTISDNResume = ((MIOC_ISDN << 8) | 104), 
    I_OTISDNResumeAcknowledge =
        ((MIOC_ISDN << 8) | 105), 
    I_OTISDNResumeReject =
        ((MIOC_ISDN << 8) | 106), 
    I_OTISDNFaciltity =
        ((MIOC_ISDN << 8) | 107) 
  };
 
  enum
  {
    kOTISDNMaxUserDataSize = 32
  };
 
  enum
  {
    ISDN_OPT_COMMTYPE = 0x0200,
    ISDN_OPT_FRAMINGTYPE = 0x0201,
    ISDN_OPT_56KADAPTATION = 0x0202
  };
 
  enum
  {
    kOTISDNTelephoneALaw = 1,   
    kOTISDNTelephoneMuLaw = 26, 
    kOTISDNDigital64k = 13,     
    kOTISDNDigital56k = 37,     
    kOTISDNVideo64k = 41,       
    kOTISDNVideo56k = 42        
  };
 
  enum
  {
    kOTISDNFramingTransparent = 0x0010, 
    kOTISDNFramingHDLC = 0x0020,        
    kOTISDNFramingV110 = 0x0040,        
    kOTISDNFramingV14E = 0x0080         
  };
 
  enum
  {
    kOTISDNNot56KAdaptation = false, 
    kOTISDN56KAdaptation = true      
  };
 
  enum
  {
    kOTISDNDefaultCommType = kOTISDNDigital64k,
    kOTISDNDefaultFramingType = kOTISDNFramingHDLC,
    kOTISDNDefault56KAdaptation = kOTISDNNot56KAdaptation
  };
 
  /********************************************************************************
   *   Constants for Open Transport-based Remote Access/PPP API
   ********************************************************************************/
 
#define kPPPControlName "ppp"
 
  enum
  {
    COM_PPP = FOUR_CHAR_CODE('PPPC')
  };
 
  enum
  {
    kPPPMaxIDLength = 255,
    kPPPMaxPasswordLength = 255,
    kPPPMaxDTEAddressLength = 127,
    kPPPMaxCallInfoLength = 255
  };
 
  enum
  {
    kPPPStateInitial = 1,
    kPPPStateClosed = 2,
    kPPPStateClosing = 3,
    kPPPStateOpening = 4,
    kPPPStateOpened = 5
  };
 
  enum
  {
    kPPPConnectionStatusIdle = 1,
    kPPPConnectionStatusConnecting = 2,
    kPPPConnectionStatusConnected = 3,
    kPPPConnectionStatusDisconnecting = 4
  };
 
  enum
  {
    kPPPMinMRU = 0,
    kPPPMaxMRU = 4500
  };
 
  enum
  {
    kIPCPTCPHdrCompressionDisabled = 0,
    kIPCPTCPHdrCompressionEnabled = 1
  };
 
  enum
  {
    kPPPCompressionDisabled = 0x00000000,
    kPPPProtoCompression = 0x00000001,
    kPPPAddrCompression = 0x00000002
  };
 
  enum
  {
    kPPPNoOutAuthentication = 0,
    kPPPCHAPOrPAPOutAuthentication = 1
  };
 
  enum
  {
    kCCReminderTimerDisabled = 0,
    kCCIPIdleTimerDisabled = 0
  };
 
  enum
  {
    kPPPScriptTypeModem = 1,
    kPPPScriptTypeConnect = 2,
    kPPPMaxScriptSize = 32000
  };
 
  enum
  {
    kE164Address = 1,
    kPhoneAddress = 1,
    kCompoundPhoneAddress = 2,
    kX121Address = 3
  };
 
  enum
  {
    kPPPConnectionStatusDialogsFlag = 0x00000001,
    kPPPConnectionRemindersFlag = 0x00000002,
    kPPPConnectionFlashingIconFlag = 0x00000004,
    kPPPOutPasswordDialogsFlag = 0x00000008,
    kPPPAllAlertsDisabledFlag = 0x00000000,
    kPPPAllAlertsEnabledFlag = 0x0000000F
  };
 
  enum
  {
    kPPPAsyncMapCharsNone = 0x00000000,
    kPPPAsyncMapCharsXOnXOff = 0x000A0000,
    kPPPAsyncMapCharsAll = (unsigned long)0xFFFFFFFF
  };
 
  enum
  {
    IPCP_OPT_GETREMOTEPROTOADDR = 0x00007000,
    IPCP_OPT_GETLOCALPROTOADDR = 0x00007001,
    IPCP_OPT_TCPHDRCOMPRESSION = 0x00007002,
    LCP_OPT_PPPCOMPRESSION = 0x00007003,
    LCP_OPT_MRU = 0x00007004,
    LCP_OPT_RCACCMAP = 0x00007005,
    LCP_OPT_TXACCMAP = 0x00007006,
    SEC_OPT_OUTAUTHENTICATION = 0x00007007,
    SEC_OPT_ID = 0x00007008,
    SEC_OPT_PASSWORD = 0x00007009,
    CC_OPT_REMINDERTIMER = 0x00007010,
    CC_OPT_IPIDLETIMER = 0x00007011,
    CC_OPT_DTEADDRESSTYPE = 0x00007012,
    CC_OPT_DTEADDRESS = 0x00007013,
    CC_OPT_CALLINFO = 0x00007014,
    CC_OPT_GETMISCINFO = 0x00007015,
    PPP_OPT_GETCURRENTSTATE = 0x00007016,
    LCP_OPT_ECHO = 0x00007017, 
    CC_OPT_SERIALPORTNAME = 0x00007200
  };
 
  enum
  {
    kPPPEvent = kPROTOCOLEVENT | 0x000F0000,
    kPPPConnectCompleteEvent = kPPPEvent + 1,
    kPPPSetScriptCompleteEvent = kPPPEvent + 2,
    kPPPDisconnectCompleteEvent = kPPPEvent + 3,
    kPPPDisconnectEvent = kPPPEvent + 4,
    kPPPIPCPUpEvent = kPPPEvent + 5,
    kPPPIPCPDownEvent = kPPPEvent + 6,
    kPPPLCPUpEvent = kPPPEvent + 7,
    kPPPLCPDownEvent = kPPPEvent + 8,
    kPPPLowerLayerUpEvent = kPPPEvent + 9,
    kPPPLowerLayerDownEvent = kPPPEvent + 10,
    kPPPAuthenticationStartedEvent = kPPPEvent + 11,
    kPPPAuthenticationFinishedEvent = kPPPEvent + 12,
    kPPPDCEInitStartedEvent = kPPPEvent + 13,
    kPPPDCEInitFinishedEvent = kPPPEvent + 14,
    kPPPDCECallStartedEvent = kPPPEvent + 15,
    kPPPDCECallFinishedEvent = kPPPEvent + 16
  };
 
#if CALL_NOT_IN_CARBON
 
#define kScriptName "Script"
 
#define gestaltOpenTptModem 'otmo'
#define gestaltOpenTptModemPresent 0
 
#define gestaltOpenTptModemVersion 'otmv'
#define kGestaltOpenTptModemVersion 0x01000080
 
#define kModemNoError 0
#define kModemOutOfMemory -14000
#define kModemPreferencesMissing -14001
#define kModemScriptMissing -14002
 
#define kModemConfigFileCreator 'modm'
#define kModemConfigFileType 'mdpf'
#define kModemConfigVersion 0x00010000
#define kModemConfigExportType 'mdex'
#define kModemScriptType 'mlts'    
#define kModemScriptCreator 'slnk' 
#define kModemConfigTypeModem 'ccl '    
#define kModemSelectedConfigID 1        
#define kModemSelectedConfigType 'ccfg' 
#define kModemConfigNameType 'cnam'     
#define kModemConfigTypeLocks 'lkmd'    
#define kModemConfigFirstID 128         
#define kMaxScriptNameSize 64
 
#define kDefaultModemPrefsFileName "\pModem Preferences"
 
  enum
  {
    kDialToneNormal = 0,
    kDialToneIgnore = 1,
    kDialToneManual = 2
  };
 
  typedef struct
  {
    UInt32 version;
    Boolean useModemScript;
    FSSpec modemScript;
    Boolean modemSpeakerOn;
    Boolean modemPulseDial;
    UInt32 modemDialToneMode;
    SInt8 lowerLayerName[kMaxProviderNameSize];
  } RAConfigModem;
 
#endif 
  /********************************************************************************
   *   IOCTL constants for I_OTConnect, I_OTDisconnect and I_OTScript
   *   are defined in OpenTransport.h
   ********************************************************************************/
 
  /********************************************************************************
   *   PPPMRULimits
   ********************************************************************************/
  struct PPPMRULimits
  {
    UInt32 mruSize; 
    UInt32 upperMRULimit;
    UInt32 lowerMRULimit;
  };
  typedef struct PPPMRULimits PPPMRULimits;
 
  /********************************************************************************
   *   CCMiscInfo
   ********************************************************************************/
  struct CCMiscInfo
  {
    UInt32 connectionStatus;
    UInt32 connectionTimeElapsed;
    UInt32 connectionTimeRemaining;
    UInt32 bytesTransmitted;
    UInt32 bytesReceived;
    UInt32 reserved;
  };
  typedef struct CCMiscInfo CCMiscInfo;
 
  /********************************************************************************
   *   LCPEcho
   ********************************************************************************/
  struct LCPEcho
  {
    UInt32 retryCount;
    UInt32 retryPeriod; 
  };
  typedef struct LCPEcho LCPEcho;
 
  /********************************************************************************
   *   Bits used to tell kind of product
   ********************************************************************************/
  enum
  {
    kRAProductClientOnly = 2,
    kRAProductOnePortServer = 3,
    kRAProductManyPortServer = 4
  };
 
#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