{
Created: Sunday, January 6, 1991 at 10:20 PM
    AppleTalk.p
    Pascal Interface to the Macintosh Libraries

        Copyright Apple Computer, Inc. 1985-1990
        All rights reserved
}


{$IFC UNDEFINED UsingIncludes}
{$SETC UsingIncludes := 0}
{$ENDC}

{$IFC NOT UsingIncludes}
    UNIT AppleTalk;
    INTERFACE
{$ENDC}

{$IFC UNDEFINED UsingAppleTalk}
{$SETC UsingAppleTalk := 1}

{$I+}
{$SETC AppleTalkIncludes := UsingIncludes}
{$SETC UsingIncludes := 1}
{$IFC UNDEFINED UsingTypes}
{$I $$Shell(PInterfaces)Types.p}
{$ENDC}
{$IFC UNDEFINED UsingOSUtils}
{$I $$Shell(PInterfaces)OSUtils.p}
{$ENDC}
{$SETC UsingIncludes := AppleTalkIncludes}

CONST

{    Driver unit and reference numbers (ADSP is dynamic)}

mppUnitNum = 9;                                                 {MPP unit number}
atpUnitNum = 10;                                                { ATP unit number }
xppUnitNum = 40;                                                { XPP unit number }
mppRefNum = -10;                                                {MPP reference number }
atpRefNum = -11;                                                { ATP reference number }
xppRefNum = -41;                                                { XPP reference number }

{    .MPP csCodes}

lookupReply = 242;                                              { This command queued to ourself }
writeLAP = 243;                                                 { Write out LAP packet }
detachPH = 244;                                                 { Detach LAP protocol handler }
attachPH = 245;                                                 { Attach LAP protocol handler }
writeDDP = 246;                                                 { Write out DDP packet }
closeSkt = 247;                                                 { Close DDP socket }
openSkt = 248;                                                  { Open DDP socket }
loadNBP = 249;                                                  { Load NBP command-executing code }
lastResident = 249;                                             { Last resident command }
confirmName = 250;                                              { Confirm name }
lookupName = 251;                                               { Look up name on internet }
removeName = 252;                                               { Remove name from Names Table }
registerName = 253;                                             { Register name in Names Table }
killNBP = 254;                                                  { Kill outstanding NBP request }
unloadNBP = 255;                                                { Unload NBP command code }
setSelfSend = 256;                                              { MPP: Set to allow writes to self }
SetMyZone = 257;                                                { Set my zone name }
GetATalkInfo = 258;                                             { get AppleTalk information }
ATalkClosePrep = 259;                                           { AppleTalk close query }

{    .ATP csCodes}

nSendRequest = 248;                                             { NSendRequest code }
relRspCB = 249;                                                 { Release RspCB }
closeATPSkt = 250;                                              { Close ATP socket }
addResponse = 251;                                              { Add response code | Require open skt }
sendResponse = 252;                                             { Send response code }
getRequest = 253;                                               { Get request code }
openATPSkt = 254;                                               { Open ATP socket }
sendRequest = 255;                                              { Send request code }
relTCB = 256;                                                   { Release TCB }
killGetReq = 257;                                               { Kill GetRequest }
killSendReq = 258;                                              { Kill SendRequest }
killAllGetReq = 259;                                            { Kill all getRequests for a skt }

{    .XPP csCodes}

openSess = 255;                                                 { Open session }
closeSess = 254;                                                { Close session }
userCommand = 253;                                              { User command }
userWrite = 252;                                                { User write }
getStatus = 251;                                                { Get status }
afpCall = 250;                                                  { AFP command (buffer has command code) }
getParms = 249;                                                 { Get parameters }
abortOS = 248;                                                  { Abort open session request }
closeAll = 247;                                                 { Close all open sessions }
xCall = 246;                                                    { .XPP extended calls }
ATTransOpen = 0;                                                {AppleTalk has opened}
ATTransClose = 2;                                               {AppleTalk is about to close}
ATTransClosePrep = 3;                                           {Is it OK to close AppleTalk ?}
ATTransCancelClose = 4;                                         {Cancel the ClosePrep transition}
afpByteRangeLock = 1;                                           {AFPCall command codes}
afpVolClose = 2;                                                {AFPCall command codes}
afpDirClose = 3;                                                {AFPCall command codes}
afpForkClose = 4;                                               {AFPCall command codes}
afpCopyFile = 5;                                                {AFPCall command codes}
afpDirCreate = 6;                                               {AFPCall command codes}
afpFileCreate = 7;                                              {AFPCall command codes}
afpDelete = 8;                                                  {AFPCall command codes}
afpEnumerate = 9;                                               {AFPCall command codes}
afpFlush = 10;                                                  {AFPCall command codes}
afpForkFlush = 11;                                              {AFPCall command codes}
afpGetDirParms = 12;                                            {AFPCall command codes}
afpGetFileParms = 13;                                           {AFPCall command codes}
afpGetForkParms = 14;                                           {AFPCall command codes}
afpGetSInfo = 15;                                               {AFPCall command codes}
afpGetSParms = 16;                                              {AFPCall command codes}
afpGetVolParms = 17;                                            {AFPCall command codes}
afpLogin = 18;                                                  {AFPCall command codes}
afpContLogin = 19;                                              {AFPCall command codes}
afpLogout = 20;                                                 {AFPCall command codes}
afpMapID = 21;                                                  {AFPCall command codes}
afpMapName = 22;                                                {AFPCall command codes}
afpMove = 23;                                                   {AFPCall command codes}
afpOpenVol = 24;                                                {AFPCall command codes}
afpOpenDir = 25;                                                {AFPCall command codes}
afpOpenFork = 26;                                               {AFPCall command codes}
afpRead = 27;                                                   {AFPCall command codes}
afpRename = 28;                                                 {AFPCall command codes}
afpSetDirParms = 29;                                            {AFPCall command codes}
afpSetFileParms = 30;                                           {AFPCall command codes}
afpSetForkParms = 31;                                           {AFPCall command codes}
afpSetVolParms = 32;                                            {AFPCall command codes}
afpWrite = 33;                                                  {AFPCall command codes}
afpGetFlDrParms = 34;                                           {AFPCall command codes}
afpSetFlDrParms = 35;                                           {AFPCall command codes}
afpDTOpen = 48;                                                 {AFPCall command codes}
afpDTClose = 49;                                                {AFPCall command codes}
afpGetIcon = 51;                                                {AFPCall command codes}
afpGtIcnInfo = 52;                                              {AFPCall command codes}
afpAddAPPL = 53;                                                {AFPCall command codes}
afpRmvAPPL = 54;                                                {AFPCall command codes}
afpGetAPPL = 55;                                                {AFPCall command codes}
afpAddCmt = 56;                                                 {AFPCall command codes}
afpRmvCmt = 57;                                                 {AFPCall command codes}
afpGetCmt = 58;                                                 {AFPCall command codes}
afpAddIcon = 192;                                               {Special code for ASP Write commands}

xppLoadedBit = 5;                                               { XPP bit in PortBUse }
scbMemSize = 192;                                               {Size of memory for SCB }
xppFlagClr = 0;                                                 {Cs for AFPCommandBlock }
xppFlagSet = 128;                                               {StartEndFlag & NewLineFlag fields. }

lapSize = 20;
ddpSize = 26;
nbpSize = 26;
atpSize = 56;
atpXOvalue = 32;                                                {ATP exactly-once bit }
atpEOMvalue = 16;                                               {ATP End-Of-Message bit }
atpSTSvalue = 8;                                                {ATP Send-Transmission-Status bit }
atpTIDValidvalue = 2;                                           {ATP trans. ID valid bit }
atpSendChkvalue = 1;                                            {ATP send checksum bit }

zipGetLocalZones = 5;
zipGetZoneList = 6;
zipGetMyZone = 7;

LAPMgrPtr = $B18;                                               {Entry point for LAP Manager}
LAPMgrCall = 2;                                                 {Offset to LAP routines}
LAddAEQ = 23;                                                   {LAPAddATQ routine selector}
LRmvAEQ = 24;                                                   {LAPRmvATQ routine selector}

TYPE
ABCallType = (tLAPRead,tLAPWrite,tDDPRead,tDDPWrite,tNBPLookup,tNBPConfirm,
    tNBPRegister,tATPSndRequest,tATPGetRequest,tATPSdRsp,tATPAddRsp,tATPRequest,
    tATPResponse);

ABProtoType = (lapProto,ddpProto,nbpProto,atpProto);


ABByte=1..127;

LAPAdrBlock = PACKED RECORD
    dstNodeID: Byte;
    srcNodeID: Byte;
    lapProtType: ABByte;
    END;

ATQEntryPtr = ^ATQEntry;
ATQEntry = RECORD
    qLink: ATQEntryPtr;                                         {next queue entry}
    qType: INTEGER;                                             {queue type}
    CallAddr: ProcPtr;                                          {pointer to your routine}
    END;

AddrBlock = PACKED RECORD
    aNet: INTEGER;
    aNode: Byte;
    aSocket: Byte;
    END;

EntityPtr = ^EntityName;
EntityName = RECORD
    objStr: Str32;
    typeStr: Str32;
    zoneStr: Str32;
    END;

RetransType = PACKED RECORD
    retransInterval: Byte;
    retransCount: Byte;
    END;

BDSElement = RECORD
    buffSize: INTEGER;
    buffPtr: Ptr;
    dataSize: INTEGER;
    userBytes: LONGINT;
    END;


BDSType = ARRAY [0..7] OF BDSElement;
BDSPtr = ^BDSType;
BitMapType = PACKED ARRAY [0..7] OF BOOLEAN;

ABRecPtr = ^ABusRecord;
ABRecHandle = ^ABRecPtr;
ABusRecord = RECORD
    abOpcode: ABCallType;
    abResult: INTEGER;
    abUserReference: LONGINT;
    CASE ABProtoType OF
      lapProto:
        (lapAddress: LAPAdrBlock;
        lapReqCount: INTEGER;
        lapActCount: INTEGER;
        lapDataPtr: Ptr);
      ddpProto:
        (ddpType: Byte;
        ddpSocket: Byte;
        ddpAddress: AddrBlock;
        ddpReqCount: INTEGER;
        ddpActCount: INTEGER;
        ddpDataPtr: Ptr;
        ddpNodeID: Byte);
      nbpProto:
        (nbpEntityPtr: EntityPtr;
        nbpBufPtr: Ptr;
        nbpBufSize: INTEGER;
        nbpDataField: INTEGER;
        nbpAddress: AddrBlock;
        nbpRetransmitInfo: RetransType);
      atpProto:
        (atpSocket: Byte;
        atpAddress: AddrBlock;
        atpReqCount: INTEGER;
        atpDataPtr: Ptr;
        atpRspBDSPtr: BDSPtr;
        atpBitmap: BitMapType;
        atpTransID: INTEGER;
        atpActCount: INTEGER;
        atpUserData: LONGINT;
        atpXO: BOOLEAN;
        atpEOM: BOOLEAN;
        atpTimeOut: Byte;
        atpRetries: Byte;
        atpNumBufs: Byte;
        atpNumRsp: Byte;
        atpBDSSize: Byte;
        atpRspUData: LONGINT;
        atpRspBuf: Ptr;
        atpRspSize: INTEGER);
    END;

AFPCommandBlock = PACKED RECORD
    cmdByte: Byte;
    startEndFlag: Byte;
    forkRefNum: INTEGER;
    rwOffset: LONGINT;
    reqCount: LONGINT;
    newLineFlag: Byte;
    newLineChar: CHAR;
    END;

WDSElement = RECORD
    entryLength: INTEGER;
    entryPtr: Ptr;
    END;

NamesTableEntry = RECORD
    qLink: QElemPtr;
    nteAddress: AddrBlock;
    nteData: PACKED ARRAY [1..100] OF CHAR;
    END;

MPPParmType = (LAPWriteParm,AttachPHParm,DetachPHParm,OpenSktParm,CloseSktParm,
    WriteDDPParm,OpenATPSktParm,CloseATPSktParm,SendRequestParm,GetRequestParm,
    SendResponseParm,AddResponseParm,RelTCBParm,RelRspCBParm,RegisterNameParm,
    LookupNameParm,ConfirmNameParm,RemoveNameParm,SetSelfSendParm,NSendRequestParm,
    KillSendReqParm,KillGetReqParm,KillNBPParm,GetAppleTalkInfoParm,KillAllGetReqParm,
    ATalkClosePrepParm,CancelATalkClosePrepParm);

MPPPBPtr = ^MPPParamBlock;
MPPParamBlock = PACKED RECORD
    qLink: QElemPtr;                                            {next queue entry}
    qType: INTEGER;                                             {queue type}
    ioTrap: INTEGER;                                            {routine trap}
    ioCmdAddr: Ptr;                                             {routine address}
    ioCompletion: ProcPtr;                                      {completion routine}
    ioResult: OSErr;                                            {result code}
    ioNamePtr: StringPtr;                                       {->filename}
    ioVRefNum: INTEGER;                                         {volume reference or drive number}
    ioRefNum: INTEGER;                                          {driver reference number}
    csCode: INTEGER;                                            {call command code AUTOMATICALLY set}
    CASE MPPParmType OF
      LAPWriteParm:
        (filler0: INTEGER;
        wdsPointer: Ptr);                                       {->Write Data Structure}
      AttachPHParm,DetachPHParm:
        (protType: Byte;                                        {ALAP Protocol Type}
        filler1: Byte;
        handler: Ptr);                                          {->protocol handler routine}
      OpenSktParm,CloseSktParm,WriteDDPParm:
        (socket: Byte;                                          {socket number}
        checksumFlag: Byte;                                     {checksum flag}
        listener: Ptr);                                         {->socket listener routine}
      RegisterNameParm,LookupNameParm,ConfirmNameParm,RemoveNameParm:
        (interval: Byte;                                        {retry interval}
        count: Byte;                                            {retry count}
        entityPtr: Ptr;                                         {->names table element or ->entity name}
        CASE MPPParmType OF
          RegisterNameParm:
            (verifyFlag: Byte;                                  {set if verify needed}
            filler3: Byte);
          LookupNameParm:
            (retBuffPtr: Ptr;                                   {->return buffer}
            retBuffSize: INTEGER;                               {return buffer size}
            maxToGet: INTEGER;                                  {matches to get}
            numGotten: INTEGER);                                {matched gotten}
          ConfirmNameParm:
            (confirmAddr: AddrBlock;                            {->entity}
            newSocket: Byte;                                    {socket number}
            filler4: Byte));
      SetSelfSendParm:
        (newSelfFlag: Byte;                                     {self-send toggle flag}
        oldSelfFlag: Byte);                                     {previous self-send state}
      KillNBPParm:
        (nKillQEl: Ptr);                                        {ptr to Q element to cancel}
      GetAppleTalkInfoParm:
        (version: INTEGER;                                      {requested info version}
        varsPtr: Ptr;                                           {pointer to well known MPP vars}
        DCEPtr: Ptr;                                            {pointer to MPP DCE}
        portID: INTEGER;                                        {port number [0..7]}
        configuration: LONGINT;                                 {32-bit configuration word}
        selfSend: INTEGER;                                      {non zero if SelfSend enabled}
        netLo: INTEGER;                                         {low value of network range}
        netHi: INTEGER;                                         {high value of network range}
        ourAddr: LONGINT;                                       {our 24-bit AppleTalk address}
        routerAddr: LONGINT;                                    {24-bit address of (last) router}
        numOfPHs: INTEGER;                                      {max. number of protocol handlers}
        numOfSkts: INTEGER;                                     {max. number of static sockets}
        numNBPEs: INTEGER;                                      {max. concurrent NBP requests}
        nTQueue: Ptr;                                           {pointer to registered name queue}
        LAlength: INTEGER;                                      {length in bytes of data link addr}
        linkAddr: Ptr;                                          {data link address returned}
        zoneName: Ptr);                                         {zone name returned}
      ATalkClosePrepParm:
        (appName: Ptr);                                         {pointer to application name in buffer}
    END;

ATPPBPtr = ^ATPParamBlock;
ATPParamBlock = PACKED RECORD
    qLink: QElemPtr;                                            {next queue entry}
    qType: INTEGER;                                             {queue type}
    ioTrap: INTEGER;                                            {routine trap}
    ioCmdAddr: Ptr;                                             {routine address}
    ioCompletion: ProcPtr;                                      {completion routine}
    ioResult: OSErr;                                            {result code}
    userData: LONGINT;                                          {ATP user bytes}
    reqTID: INTEGER;                                            {request transaction ID}
    ioRefNum: INTEGER;                                          {driver reference number}
    csCode: INTEGER;                                            {Call command code automatically set}
    atpSocket: Byte;                                            {currBitMap or socket number}
    CASE MPPParmType OF 
        SendRequestParm, SendResponseParm, GetRequestParm, AddResponseParm, KillSendReqParm:
        (atpFlags: Byte;                                        {control information}
        addrBlock: AddrBlock;                                   {source/dest. socket address}
        reqLength: INTEGER;                                     {request/response length}
        reqPointer: Ptr;                                        {-> request/response data}
        bdsPointer: Ptr;                                        {-> response BDS}
        CASE MPPParmType OF
          SendRequestParm:
            (numOfBuffs: Byte;                                  {number of responses expected}
            timeOutVal: Byte;                                   {timeout interval}
            numOfResps: Byte;                                   {number of responses actually received}
            retryCount: Byte;                                   {number of retries}
            intBuff: INTEGER;                                   {used internally for NSendRequest}
            TRelTime: Byte);                                    {TRelease time for extended send request}
          SendResponseParm:
            (filler0: Byte;                                     {numOfBuffs}
            bdsSize: Byte;                                      {number of BDS elements}
            transID: INTEGER);                                  {transaction ID}
          GetRequestParm:
            (bitMap: Byte;                                      {bit map}
            filler1: Byte);
          AddResponseParm:
            (rspNum: Byte;                                      {sequence number}
            filler2: Byte);
          KillSendReqParm:
            (aKillQEl: Ptr));                                   {ptr to Q element to cancel}
    END;

XPPPrmBlkType = (XPPPrmBlk,ASPSizeBlk,ASPAbortPrm,XCallParam);

XPPSubPrmType = (ASPOpenPrm,ASPSubPrm);

XPPEndPrmType = (AFPLoginPrm,ASPEndPrm);

XPPParmBlkPtr = ^XPPParamBlock;
XPPParamBlock = PACKED RECORD
    qLink: QElemPtr;                                            {next queue entry}
    qType: INTEGER;                                             {queue type}
    ioTrap: INTEGER;                                            {routine trap}
    ioCmdAddr: Ptr;                                             {routine address}
    ioCompletion: ProcPtr;                                      {completion routine}
    ioResult: OSErr;                                            {result code}
    cmdResult: LONGINT;                                         {command result (ATP user bytes)}
    ioVRefNum: INTEGER;                                         {volume reference or drive number}
    ioRefNum: INTEGER;                                          {driver reference number}
    csCode: INTEGER;                                            {call command code}
    CASE XPPPrmBlkType OF
      ASPAbortPrm:
        (abortSCBPtr: Ptr);                                     {SCB pointer for AbortOS}
      ASPSizeBlk:
        (aspMaxCmdSize: INTEGER;                                {for SPGetParms}
        aspQuantumSize: INTEGER;                                {for SPGetParms}
        numSesss: INTEGER);                                     {for SPGetParms}
      XPPPrmBlk:
        (sessRefnum: INTEGER;                                   {offset to session refnum}
        aspTimeout: Byte;                                       {timeout for ATP}
        aspRetry: Byte;                                         {retry count for ATP}
        CASE XPPSubPrmType OF
          ASPOpenPrm:
            (serverAddr: AddrBlock;                             {server address block}
            scbPointer: Ptr;                                    {SCB pointer}
            attnRoutine: Ptr);                                  {attention routine pointer}
          ASPSubPrm:
            (cbSize: INTEGER;                                   {command block size}
            cbPtr: Ptr;                                         {command block pointer}
            rbSize: INTEGER;                                    {reply buffer size}
            rbPtr: Ptr;                                         {reply buffer pointer}
            CASE XPPEndPrmType OF
              AFPLoginPrm:
                (afpAddrBlock: AddrBlock;                       {address block in AFP login}
                afpSCBPtr: Ptr;                                 {SCB pointer in AFP login}
                afpAttnRoutine: Ptr);                           {Attn routine pointer in AFP login}
              ASPEndPrm:
                (wdSize: INTEGER;                               {write data size}
                wdPtr: Ptr;                                     {write data pointer}
                ccbStart: ARRAY [0..295] OF Byte)));            {afpWrite max size = 296, else 150}
      XCallParam:
        (xppSubCode: INTEGER;
        xppTimeout: Byte;                                       {retry interval (seconds)}
        xppRetry: Byte;                                         {retry count}
        filler1: INTEGER;                                       {word space for rent.  see the super.}
        zipBuffPtr: Ptr;                                        {pointer to buffer (must be 578 bytes)}
        zipNumZones: INTEGER;                                   {no. of zone names in this response}
        zipLastFlag: Byte;                                      {non-zero if no more zones}
        filler2: Byte;                                          {filler}
        zipInfoField: PACKED ARRAY [1..70] OF Byte);            {on initial call, set first word to zero}
    END;


FUNCTION OpenXPP(VAR xppRefnum: INTEGER): OSErr;
FUNCTION ASPOpenSession(thePBptr: XPPParmBlkPtr;async: BOOLEAN): OSErr;
FUNCTION ASPCloseSession(thePBptr: XPPParmBlkPtr;async: BOOLEAN): OSErr;
FUNCTION ASPAbortOS(thePBptr: XPPParmBlkPtr;async: BOOLEAN): OSErr;
FUNCTION ASPGetParms(thePBptr: XPPParmBlkPtr;async: BOOLEAN): OSErr;
FUNCTION ASPCloseAll(thePBptr: XPPParmBlkPtr;async: BOOLEAN): OSErr;
FUNCTION ASPUserWrite(thePBptr: XPPParmBlkPtr;async: BOOLEAN): OSErr;
FUNCTION ASPUserCommand(thePBptr: XPPParmBlkPtr;async: BOOLEAN): OSErr;
FUNCTION ASPGetStatus(thePBptr: XPPParmBlkPtr;async: BOOLEAN): OSErr;
FUNCTION AFPCommand(thePBptr: XPPParmBlkPtr;async: BOOLEAN): OSErr;
FUNCTION GetLocalZones(thePBptr: XPPParmBlkPtr;async: BOOLEAN): OSErr;
FUNCTION GetZoneList(thePBptr: XPPParmBlkPtr;async: BOOLEAN): OSErr;
FUNCTION GetMyZone(thePBptr: XPPParmBlkPtr;async: BOOLEAN): OSErr;
FUNCTION PAttachPH(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PDetachPH(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PWriteLAP(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
FUNCTION POpenSkt(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PCloseSkt(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PWriteDDP(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PRegisterName(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PLookupName(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PConfirmName(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PRemoveName(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PSetSelfSend(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PKillNBP(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PGetAppleTalkInfo(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PATalkClosePrep(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
FUNCTION POpenATPSkt(thePBptr: ATPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PCloseATPSkt(thePBPtr: ATPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PSendRequest(thePBPtr: ATPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PGetRequest(thePBPtr: ATPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PSendResponse(thePBPtr: ATPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PAddResponse(thePBPtr: ATPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PRelTCB(thePBPtr: ATPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PRelRspCB(thePBPtr: ATPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PNSendRequest(thePBPtr: ATPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PKillSendReq(thePBPtr: ATPPBPtr;async: BOOLEAN): OSErr;
FUNCTION PKillGetReq(thePBPtr: ATPPBPtr;async: BOOLEAN): OSErr;
FUNCTION ATPKillAllGetReq(thePBPtr: ATPPBPtr;async: BOOLEAN): OSErr;
PROCEDURE BuildLAPwds(wdsPtr: Ptr;dataPtr: Ptr;destHost: INTEGER;prototype: INTEGER;
    frameLen: INTEGER);
PROCEDURE BuildDDPwds(wdsPtr: Ptr;headerPtr: Ptr;dataPtr: Ptr;netAddr: AddrBlock;
    ddpType: INTEGER;dataLen: INTEGER);
PROCEDURE NBPSetEntity(buffer: Ptr;nbpObject: Str32;nbpType: Str32;nbpZone: Str32);
PROCEDURE NBPSetNTE(ntePtr: Ptr;nbpObject: Str32;nbpType: Str32;nbpZone: Str32;
    socket: INTEGER);
FUNCTION GetBridgeAddress: INTEGER;
FUNCTION BuildBDS(buffPtr: Ptr;bdsPtr: Ptr;buffSize: INTEGER): INTEGER;
FUNCTION MPPOpen: OSErr;
FUNCTION MPPClose: OSErr;
FUNCTION LAPOpenProtocol(theLAPType: ABByte;protoPtr: Ptr): OSErr;
FUNCTION LAPCloseProtocol(theLAPType: ABByte): OSErr;
FUNCTION LAPWrite(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
FUNCTION LAPRead(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
FUNCTION LAPRdCancel(abRecord: ABRecHandle): OSErr;
FUNCTION LAPAddATQ(theATQEntry: ATQEntryPtr): OSErr;
FUNCTION LAPRmvATQ(theATQEntry: ATQEntryPtr): OSErr;
FUNCTION DDPOpenSocket(VAR theSocket: Byte;sktListener: Ptr): OSErr;
FUNCTION DDPCloseSocket(theSocket: Byte): OSErr;
FUNCTION DDPRead(abRecord: ABRecHandle;retCksumErrs: BOOLEAN;async: BOOLEAN): OSErr;
FUNCTION DDPWrite(abRecord: ABRecHandle;doChecksum: BOOLEAN;async: BOOLEAN): OSErr;
FUNCTION DDPRdCancel(abRecord: ABRecHandle): OSErr;
FUNCTION ATPLoad: OSErr;
FUNCTION ATPUnload: OSErr;
FUNCTION ATPOpenSocket(addrRcvd: AddrBlock;VAR atpSocket: Byte): OSErr;
FUNCTION ATPCloseSocket(atpSocket: Byte): OSErr;
FUNCTION ATPSndRequest(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
FUNCTION ATPRequest(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
FUNCTION ATPReqCancel(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
FUNCTION ATPGetRequest(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
FUNCTION ATPSndRsp(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
FUNCTION ATPAddRsp(abRecord: ABRecHandle): OSErr;
FUNCTION ATPResponse(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
FUNCTION ATPRspCancel(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
FUNCTION NBPRegister(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
FUNCTION NBPLookup(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
FUNCTION NBPExtract(theBuffer: Ptr;numInBuf: INTEGER;whichOne: INTEGER;
    VAR abEntity: EntityName;VAR address: AddrBlock): OSErr;
FUNCTION NBPConfirm(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
FUNCTION NBPRemove(abEntity: EntityPtr): OSErr;
FUNCTION NBPLoad: OSErr;
FUNCTION NBPUnload: OSErr;
FUNCTION GetNodeAddress(VAR myNode: INTEGER;VAR myNet: INTEGER): OSErr;
FUNCTION IsMPPOpen: BOOLEAN;
FUNCTION IsATPOpen: BOOLEAN;
PROCEDURE ATEvent(event: LONGINT;infoPtr: Ptr);
FUNCTION ATPreFlightEvent(event: LONGINT;cancel: LONGINT;infoPtr: Ptr): OSErr;


{$ENDC}    { UsingAppleTalk }

{$IFC NOT UsingIncludes}
    END.
{$ENDC}

