MacTCP.h

Go to the documentation of this file.

 
#ifndef __MACTCP__
#define __MACTCP__
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __MIXEDMODE__
#include <MixedMode.h>
#endif
 
#ifndef __APPLETALK__
#include <AppleTalk.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
 
  enum
  {
    inProgress = 1,             
    ipBadLapErr = -23000,       
    ipBadCnfgErr = -23001,      
    ipNoCnfgErr = -23002,       
    ipLoadErr = -23003,         
    ipBadAddr = -23004,         
    connectionClosing = -23005, 
    invalidLength = -23006,
    connectionExists = -23007,      
    connectionDoesntExist = -23008, 
    insufficientResources =
        -23009, 
    invalidStreamPtr = -23010,
    streamAlreadyOpen = -23011,
    connectionTerminated = -23012,
    invalidBufPtr = -23013,
    invalidRDS = -23014,
    invalidWDS = -23014,
    openFailed = -23015,
    commandTimeout = -23016,
    duplicateSocket = -23017
  };
 
  enum
  {
    ipDontFragErr = -23032,      
    ipDestDeadErr = -23033,      
    icmpEchoTimeoutErr = -23035, 
    ipNoFragMemErr = -23036,     
    ipRouteErr = -23037,         
    nameSyntaxErr = -23041,
    cacheFault = -23042,
    noResultProc = -23043,
    noNameServer = -23044,
    authNameErr = -23045,
    noAnsErr = -23046,
    dnrErr = -23047,
    outOfMemory = -23048
  };
 
  enum
  {
    BYTES_16WORD = 2, 
    BYTES_32WORD = 4, 
    BYTES_64WORD = 8  
  };
 
  typedef UInt8 b_8;
  typedef UInt16 b_16;
  typedef UInt32 b_32;
  typedef b_32 ip_addr;
  struct ip_addrbytes
  {
    union
    {
      b_32 addr;
      UInt8 byte[4];
    } a;
  };
  typedef struct ip_addrbytes ip_addrbytes;
  struct wdsEntry
  {
    unsigned short length; 
    Ptr ptr;               
  };
  typedef struct wdsEntry wdsEntry;
  struct rdsEntry
  {
    unsigned short length; 
    Ptr ptr;               
  };
  typedef struct rdsEntry rdsEntry;
 
  typedef unsigned long BufferPtr;
  typedef unsigned long StreamPtr;
  enum
  {
    netUnreach = 0,
    hostUnreach = 1,
    protocolUnreach = 2,
    portUnreach = 3,
    fragReqd = 4,
    sourceRouteFailed = 5,
    timeExceeded = 6,
    parmProblem = 7,
    missingOption = 8,
    lastICMPMsgType = 32767
  };
 
  typedef unsigned short ICMPMsgType;
  typedef b_16 ip_port;
  struct ICMPReport
  {
    StreamPtr streamPtr;
    ip_addr localHost;
    ip_port localPort;
    ip_addr remoteHost;
    ip_port remotePort;
    short reportType;
    unsigned short optionalAddlInfo;
    unsigned long optionalAddlInfoPtr;
  };
  typedef struct ICMPReport ICMPReport;
  enum
  {
    ipctlGetAddr = 15
  };
 
  typedef struct GetAddrParamBlock GetAddrParamBlock;
  typedef CALLBACK_API_C(void, GetIPIOCompletionProcPtr)(GetAddrParamBlock *iopb);
  typedef STACK_UPP_TYPE(GetIPIOCompletionProcPtr) GetIPIOCompletionUPP;
  struct GetAddrParamBlock
  {
    QElem *qLink;
    short qType;
    short ioTrap;
    Ptr ioCmdAddr;
    GetIPIOCompletionUPP ioCompletion;
    OSErr ioResult;
    StringPtr ioNamePtr;
    short ioVRefNum;
    short ioCRefNum;
    short csCode;
    ip_addr ourAddress; 
    long ourNetMask;    
  };
 
  enum
  {
    ipctlEchoICMP = 17, 
    ipctlLAPStats = 19  
  };
 
  typedef struct ICMPParamBlock ICMPParamBlock;
  typedef CALLBACK_API_C(void, IPIOCompletionProcPtr)(ICMPParamBlock *iopb);
  typedef STACK_UPP_TYPE(IPIOCompletionProcPtr) IPIOCompletionUPP;
  struct ICMPParamBlock
  {
    QElem *qLink;
    short qType;
    short ioTrap;
    Ptr ioCmdAddr;
    IPIOCompletionUPP ioCompletion;
    OSErr ioResult;
    StringPtr ioNamePtr;
    short ioVRefNum;
    short ioCRefNum;
    short csCode;
    short params[11];
    struct
    {
      unsigned long
          echoRequestOut; 
      unsigned long
          echoReplyIn;     
      rdsEntry echoedData; 
      Ptr options;
      unsigned long userDataPtr;
    } icmpEchoInfo;
  };
 
  typedef CALLBACK_API_C(void, ICMPEchoNotifyProcPtr)(ICMPParamBlock *iopb);
  typedef STACK_UPP_TYPE(ICMPEchoNotifyProcPtr) ICMPEchoNotifyUPP;
  typedef struct LAPStats LAPStats;
  struct IPParamBlock
  {
    QElem *qLink;
    short qType;
    short ioTrap;
    Ptr ioCmdAddr;
    IPIOCompletionUPP ioCompletion;
    OSErr ioResult;
    StringPtr ioNamePtr;
    short ioVRefNum;
    short ioCRefNum;
    short csCode;
    union
    {
      struct
      {
        ip_addr dest; 
        wdsEntry data;
        short timeout;
        Ptr options;
        unsigned short optLength;
        ICMPEchoNotifyUPP icmpCompletion;
        unsigned long userDataPtr;
      } IPEchoPB;
      struct
      {
        LAPStats *lapStatsPtr;
      } LAPStatsPB;
    } csParam;
  };
  typedef struct IPParamBlock IPParamBlock;
 
  struct nbp_entry
  {
    ip_addr ip_address;   
    AddrBlock at_address; 
    Boolean gateway;      
    Boolean valid;        
    Boolean probing;      
    SInt8 afiller;        
    long age;             
    long access;          
    SInt8 filler[116];    
  };
  typedef struct nbp_entry nbp_entry;
  struct Enet_addr
  {
    b_16 en_hi;
    b_32 en_lo;
  };
  typedef struct Enet_addr Enet_addr;
  struct arp_entry
  {
    short age;            
    b_16 protocol;        
    ip_addr ip_address;   
    Enet_addr en_address; 
  };
  typedef struct arp_entry arp_entry;
  union LAPStatsAddrXlation
  {
    arp_entry *arp_table;
    nbp_entry *nbp_table;
  };
  typedef union LAPStatsAddrXlation LAPStatsAddrXlation;
  struct LAPStats
  {
    short ifType;
    char *ifString;
    short ifMaxMTU;
    long ifSpeed;
    short ifPhyAddrLength;
    char *ifPhysicalAddress;
    LAPStatsAddrXlation AddrXlation;
    short slotNumber;
  };
 
  enum
  {
    ARP_TABLE_SIZE = 20
  };
 
  enum
  {
    NBP_TABLE_SIZE = 20, 
    NBP_MAX_NAME_SIZE = 16 + 10 + 2
  };
 
  enum
  {
    TCPCreate = 30,
    TCPPassiveOpen = 31,
    TCPActiveOpen = 32,
    TCPSend = 34,
    TCPNoCopyRcv = 35,
    TCPRcvBfrReturn = 36,
    TCPRcv = 37,
    TCPClose = 38,
    TCPAbort = 39,
    TCPStatus = 40,
    TCPExtendedStat = 41,
    TCPRelease = 42,
    TCPGlobalInfo = 43,
    TCPCtlMax = 49
  };
 
  enum
  {
    TCPClosing = 1,
    TCPULPTimeout = 2,
    TCPTerminate = 3,
    TCPDataArrival = 4,
    TCPUrgent = 5,
    TCPICMPReceived = 6,
    lastEvent = 32767
  };
 
  typedef unsigned short TCPEventCode;
  enum
  {
    TCPRemoteAbort = 2,
    TCPNetworkFailure = 3,
    TCPSecPrecMismatch = 4,
    TCPULPTimeoutTerminate = 5,
    TCPULPAbort = 6,
    TCPULPClose = 7,
    TCPServiceError = 8,
    lastReason = 32767
  };
 
  typedef unsigned short TCPTerminationReason;
  typedef CALLBACK_API(void, TCPNotifyProcPtr)(StreamPtr tcpStream,
                                               unsigned short eventCode,
                                               Ptr userDataPtr,
                                               unsigned short terminReason,
                                               ICMPReport *icmpMsg);
  typedef STACK_UPP_TYPE(TCPNotifyProcPtr) TCPNotifyUPP;
  typedef unsigned short tcp_port;
  enum
  {
    timeoutValue = 0x80,
    timeoutAction = 0x40,
    typeOfService = 0x20,
    precedence = 0x10
  };
 
  enum
  {
    lowDelay = 0x01,
    throughPut = 0x02,
    reliability = 0x04
  };
 
  struct TCPCreatePB
  {
    Ptr rcvBuff;
    unsigned long rcvBuffLen;
    TCPNotifyUPP notifyProc;
    Ptr userDataPtr;
  };
  typedef struct TCPCreatePB TCPCreatePB;
  struct TCPOpenPB
  {
    SInt8 ulpTimeoutValue;
    SInt8 ulpTimeoutAction;
    SInt8 validityFlags;
    SInt8 commandTimeoutValue;
    ip_addr remoteHost;
    tcp_port remotePort;
    ip_addr localHost;
    tcp_port localPort;
    SInt8 tosFlags;
    SInt8 precedence;
    Boolean dontFrag;
    SInt8 timeToLive;
    SInt8 security;
    SInt8 optionCnt;
    SInt8 options[40];
    Ptr userDataPtr;
  };
  typedef struct TCPOpenPB TCPOpenPB;
 
  struct TCPSendPB
  {
    SInt8 ulpTimeoutValue;
    SInt8 ulpTimeoutAction;
    SInt8 validityFlags;
    Boolean pushFlag;
    Boolean urgentFlag;
    SInt8 filler; 
    Ptr wdsPtr;
    unsigned long sendFree;
    unsigned short sendLength;
    Ptr userDataPtr;
  };
  typedef struct TCPSendPB TCPSendPB;
 
  struct TCPReceivePB
  {
    SInt8 commandTimeoutValue;
    Boolean markFlag;
    Boolean urgentFlag;
    SInt8 filler; 
    Ptr rcvBuff;
    unsigned short rcvBuffLen;
    Ptr rdsPtr;
    unsigned short rdsLength;
    unsigned short secondTimeStamp;
    Ptr userDataPtr;
  };
  typedef struct TCPReceivePB TCPReceivePB;
 
  struct TCPClosePB
  {
    SInt8 ulpTimeoutValue;
    SInt8 ulpTimeoutAction;
    SInt8 validityFlags;
    SInt8 filler; 
    Ptr userDataPtr;
  };
  typedef struct TCPClosePB TCPClosePB;
  struct HistoBucket
  {
    unsigned short value;
    unsigned long counter;
  };
  typedef struct HistoBucket HistoBucket;
  enum
  {
    NumOfHistoBuckets = 7
  };
 
  struct TCPConnectionStats
  {
    unsigned long dataPktsRcvd;
    unsigned long dataPktsSent;
    unsigned long dataPktsResent;
    unsigned long bytesRcvd;
    unsigned long bytesRcvdDup;
    unsigned long bytesRcvdPastWindow;
    unsigned long bytesSent;
    unsigned long bytesResent;
    unsigned short numHistoBuckets;
    HistoBucket sentSizeHisto[7];
    unsigned short lastRTT;
    unsigned short tmrSRTT;
    unsigned short rttVariance;
    unsigned short tmrRTO;
    SInt8 sendTries;
    SInt8 sourchQuenchRcvd;
  };
  typedef struct TCPConnectionStats TCPConnectionStats;
  struct TCPStatusPB
  {
    SInt8 ulpTimeoutValue;
    SInt8 ulpTimeoutAction;
    long unused;
    ip_addr remoteHost;
    tcp_port remotePort;
    ip_addr localHost;
    tcp_port localPort;
    SInt8 tosFlags;
    SInt8 precedence;
    SInt8 connectionState;
    SInt8 filler; 
    unsigned short sendWindow;
    unsigned short rcvWindow;
    unsigned short amtUnackedData;
    unsigned short amtUnreadData;
    Ptr securityLevelPtr;
    unsigned long sendUnacked;
    unsigned long sendNext;
    unsigned long congestionWindow;
    unsigned long rcvNext;
    unsigned long srtt;
    unsigned long lastRTT;
    unsigned long sendMaxSegSize;
    TCPConnectionStats *connStatPtr;
    Ptr userDataPtr;
  };
  typedef struct TCPStatusPB TCPStatusPB;
  struct TCPAbortPB
  {
    Ptr userDataPtr;
  };
  typedef struct TCPAbortPB TCPAbortPB;
  struct TCPParam
  {
    unsigned long tcpRtoA;
    unsigned long tcpRtoMin;
    unsigned long tcpRtoMax;
    unsigned long tcpMaxSegSize;
    unsigned long tcpMaxConn;
    unsigned long tcpMaxWindow;
  };
  typedef struct TCPParam TCPParam;
  struct TCPStats
  {
    unsigned long tcpConnAttempts;
    unsigned long tcpConnOpened;
    unsigned long tcpConnAccepted;
    unsigned long tcpConnClosed;
    unsigned long tcpConnAborted;
    unsigned long tcpOctetsIn;
    unsigned long tcpOctetsOut;
    unsigned long tcpOctetsInDup;
    unsigned long tcpOctetsRetrans;
    unsigned long tcpInputPkts;
    unsigned long tcpOutputPkts;
    unsigned long tcpDupPkts;
    unsigned long tcpRetransPkts;
  };
  typedef struct TCPStats TCPStats;
 
  typedef StreamPtr *StreamPPtr;
  struct TCPGlobalInfoPB
  {
    TCPParam *tcpParamPtr;
    TCPStats *tcpStatsPtr;
    StreamPPtr tcpCDBTable[1];
    Ptr userDataPtr;
    unsigned short maxTCPConnections;
  };
  typedef struct TCPGlobalInfoPB TCPGlobalInfoPB;
  typedef struct TCPiopb TCPiopb;
  typedef CALLBACK_API_C(void, TCPIOCompletionProcPtr)(TCPiopb *iopb);
  typedef STACK_UPP_TYPE(TCPIOCompletionProcPtr) TCPIOCompletionUPP;
  struct TCPiopb
  {
    SInt8 fill12[12];
    TCPIOCompletionUPP ioCompletion;
    short ioResult;
    Ptr ioNamePtr;
    short ioVRefNum;
    short ioCRefNum;
    short csCode;
    StreamPtr tcpStream;
    union
    {
      TCPCreatePB create;
      TCPOpenPB open;
      TCPSendPB send;
      TCPReceivePB receive;
      TCPClosePB close;
      TCPAbortPB abort;
      TCPStatusPB status;
      TCPGlobalInfoPB globalInfo;
    } csParam;
  };
 
  enum
  {
    UDPCreate = 20,
    UDPRead = 21,
    UDPBfrReturn = 22,
    UDPWrite = 23,
    UDPRelease = 24,
    UDPMaxMTUSize = 25,
    UDPStatus = 26,
    UDPMultiCreate = 27,
    UDPMultiSend = 28,
    UDPMultiRead = 29,
    UDPCtlMax = 29
  };
 
  enum
  {
    UDPDataArrival = 1,
    UDPICMPReceived = 2,
    lastUDPEvent = 32767
  };
 
  typedef unsigned short UDPEventCode;
  typedef CALLBACK_API(void, UDPNotifyProcPtr)(StreamPtr udpStream,
                                               unsigned short eventCode,
                                               Ptr userDataPtr,
                                               ICMPReport *icmpMsg);
  typedef STACK_UPP_TYPE(UDPNotifyProcPtr) UDPNotifyUPP;
  typedef unsigned short udp_port;
  struct UDPCreatePB
  {
    Ptr rcvBuff;
    unsigned long rcvBuffLen;
    UDPNotifyUPP notifyProc;
    unsigned short localPort;
    Ptr userDataPtr;
    udp_port endingPort;
  };
  typedef struct UDPCreatePB UDPCreatePB;
  struct UDPSendPB
  {
    unsigned short reserved;
    ip_addr remoteHost;
    udp_port remotePort;
    Ptr wdsPtr;
    Boolean checkSum;
    SInt8 filler; 
    unsigned short sendLength;
    Ptr userDataPtr;
    udp_port localPort;
  };
  typedef struct UDPSendPB UDPSendPB;
  struct UDPReceivePB
  {
    unsigned short timeOut;
    ip_addr remoteHost;
    udp_port remotePort;
    Ptr rcvBuff;
    unsigned short rcvBuffLen;
    unsigned short secondTimeStamp;
    Ptr userDataPtr;
    ip_addr destHost;  
    udp_port destPort; 
  };
  typedef struct UDPReceivePB UDPReceivePB;
  struct UDPMTUPB
  {
    unsigned short mtuSize;
    ip_addr remoteHost;
    Ptr userDataPtr;
  };
  typedef struct UDPMTUPB UDPMTUPB;
  typedef struct UDPiopb UDPiopb;
  typedef CALLBACK_API_C(void, UDPIOCompletionProcPtr)(UDPiopb *iopb);
  typedef STACK_UPP_TYPE(UDPIOCompletionProcPtr) UDPIOCompletionUPP;
  struct UDPiopb
  {
    SInt8 fill12[12];
    UDPIOCompletionUPP ioCompletion;
    short ioResult;
    Ptr ioNamePtr;
    short ioVRefNum;
    short ioCRefNum;
    short csCode;
    StreamPtr udpStream;
    union
    {
      UDPCreatePB create;
      UDPSendPB send;
      UDPReceivePB receive;
      UDPMTUPB mtu;
    } csParam;
  };
 
#if CALL_NOT_IN_CARBON
  GetIPIOCompletionUPP
  NewGetIPIOCompletionUPP(GetIPIOCompletionProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppGetIPIOCompletionProcInfo = 0x000000C1
  }; 
#ifdef __cplusplus
  inline GetIPIOCompletionUPP
  NewGetIPIOCompletionUPP(GetIPIOCompletionProcPtr userRoutine)
  {
    return (GetIPIOCompletionUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppGetIPIOCompletionProcInfo,
        GetCurrentArchitecture());
  }
#else
#define NewGetIPIOCompletionUPP(userRoutine)                                \
  (GetIPIOCompletionUPP) NewRoutineDescriptor((ProcPtr)(userRoutine),       \
                                              uppGetIPIOCompletionProcInfo, \
                                              GetCurrentArchitecture())
#endif
#endif
 
  IPIOCompletionUPP
  NewIPIOCompletionUPP(IPIOCompletionProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppIPIOCompletionProcInfo = 0x000000C1
  }; 
#ifdef __cplusplus
  inline IPIOCompletionUPP
  NewIPIOCompletionUPP(IPIOCompletionProcPtr userRoutine)
  {
    return (IPIOCompletionUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                   uppIPIOCompletionProcInfo,
                                                   GetCurrentArchitecture());
  }
#else
#define NewIPIOCompletionUPP(userRoutine)                                     \
  (IPIOCompletionUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppIPIOCompletionProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  ICMPEchoNotifyUPP
  NewICMPEchoNotifyUPP(ICMPEchoNotifyProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppICMPEchoNotifyProcInfo = 0x000000C1
  }; 
#ifdef __cplusplus
  inline ICMPEchoNotifyUPP
  NewICMPEchoNotifyUPP(ICMPEchoNotifyProcPtr userRoutine)
  {
    return (ICMPEchoNotifyUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                   uppICMPEchoNotifyProcInfo,
                                                   GetCurrentArchitecture());
  }
#else
#define NewICMPEchoNotifyUPP(userRoutine)                                     \
  (ICMPEchoNotifyUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppICMPEchoNotifyProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  TCPNotifyUPP
  NewTCPNotifyUPP(TCPNotifyProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppTCPNotifyProcInfo = 0x0000EEC0
  }; 
#ifdef __cplusplus
  inline TCPNotifyUPP NewTCPNotifyUPP(TCPNotifyProcPtr userRoutine)
  {
    return (TCPNotifyUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppTCPNotifyProcInfo, GetCurrentArchitecture());
  }
#else
#define NewTCPNotifyUPP(userRoutine)   \
  (TCPNotifyUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppTCPNotifyProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  TCPIOCompletionUPP
  NewTCPIOCompletionUPP(TCPIOCompletionProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppTCPIOCompletionProcInfo = 0x000000C1
  }; 
#ifdef __cplusplus
  inline TCPIOCompletionUPP
  NewTCPIOCompletionUPP(TCPIOCompletionProcPtr userRoutine)
  {
    return (TCPIOCompletionUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                    uppTCPIOCompletionProcInfo,
                                                    GetCurrentArchitecture());
  }
#else
#define NewTCPIOCompletionUPP(userRoutine)                                     \
  (TCPIOCompletionUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppTCPIOCompletionProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  UDPNotifyUPP
  NewUDPNotifyUPP(UDPNotifyProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppUDPNotifyProcInfo = 0x00003EC0
  }; 
#ifdef __cplusplus
  inline UDPNotifyUPP NewUDPNotifyUPP(UDPNotifyProcPtr userRoutine)
  {
    return (UDPNotifyUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppUDPNotifyProcInfo, GetCurrentArchitecture());
  }
#else
#define NewUDPNotifyUPP(userRoutine)   \
  (UDPNotifyUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppUDPNotifyProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  UDPIOCompletionUPP
  NewUDPIOCompletionUPP(UDPIOCompletionProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppUDPIOCompletionProcInfo = 0x000000C1
  }; 
#ifdef __cplusplus
  inline UDPIOCompletionUPP
  NewUDPIOCompletionUPP(UDPIOCompletionProcPtr userRoutine)
  {
    return (UDPIOCompletionUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                    uppUDPIOCompletionProcInfo,
                                                    GetCurrentArchitecture());
  }
#else
#define NewUDPIOCompletionUPP(userRoutine)                                     \
  (UDPIOCompletionUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppUDPIOCompletionProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeGetIPIOCompletionUPP(GetIPIOCompletionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeGetIPIOCompletionUPP(GetIPIOCompletionUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeGetIPIOCompletionUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeIPIOCompletionUPP(IPIOCompletionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeIPIOCompletionUPP(IPIOCompletionUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeIPIOCompletionUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeICMPEchoNotifyUPP(ICMPEchoNotifyUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeICMPEchoNotifyUPP(ICMPEchoNotifyUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeICMPEchoNotifyUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeTCPNotifyUPP(TCPNotifyUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeTCPNotifyUPP(TCPNotifyUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeTCPNotifyUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeTCPIOCompletionUPP(TCPIOCompletionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeTCPIOCompletionUPP(TCPIOCompletionUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeTCPIOCompletionUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeUDPNotifyUPP(UDPNotifyUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeUDPNotifyUPP(UDPNotifyUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeUDPNotifyUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeUDPIOCompletionUPP(UDPIOCompletionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeUDPIOCompletionUPP(UDPIOCompletionUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeUDPIOCompletionUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  InvokeGetIPIOCompletionUPP(GetAddrParamBlock *iopb,
                             GetIPIOCompletionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeGetIPIOCompletionUPP(GetAddrParamBlock *iopb,
                                         GetIPIOCompletionUPP userUPP)
  {
    CALL_ONE_PARAMETER_UPP(userUPP, uppGetIPIOCompletionProcInfo, iopb);
  }
#else
#define InvokeGetIPIOCompletionUPP(iopb, userUPP) \
  CALL_ONE_PARAMETER_UPP((userUPP), uppGetIPIOCompletionProcInfo, (iopb))
#endif
#endif
 
  void
  InvokeIPIOCompletionUPP(ICMPParamBlock *iopb, IPIOCompletionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeIPIOCompletionUPP(ICMPParamBlock *iopb,
                                      IPIOCompletionUPP userUPP)
  {
    CALL_ONE_PARAMETER_UPP(userUPP, uppIPIOCompletionProcInfo, iopb);
  }
#else
#define InvokeIPIOCompletionUPP(iopb, userUPP) \
  CALL_ONE_PARAMETER_UPP((userUPP), uppIPIOCompletionProcInfo, (iopb))
#endif
#endif
 
  void
  InvokeICMPEchoNotifyUPP(ICMPParamBlock *iopb, ICMPEchoNotifyUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeICMPEchoNotifyUPP(ICMPParamBlock *iopb,
                                      ICMPEchoNotifyUPP userUPP)
  {
    CALL_ONE_PARAMETER_UPP(userUPP, uppICMPEchoNotifyProcInfo, iopb);
  }
#else
#define InvokeICMPEchoNotifyUPP(iopb, userUPP) \
  CALL_ONE_PARAMETER_UPP((userUPP), uppICMPEchoNotifyProcInfo, (iopb))
#endif
#endif
 
  void
  InvokeTCPNotifyUPP(StreamPtr tcpStream, unsigned short eventCode,
                     Ptr userDataPtr, unsigned short terminReason,
                     ICMPReport *icmpMsg, TCPNotifyUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeTCPNotifyUPP(StreamPtr tcpStream, unsigned short eventCode,
                                 Ptr userDataPtr, unsigned short terminReason,
                                 ICMPReport *icmpMsg, TCPNotifyUPP userUPP)
  {
    CALL_FIVE_PARAMETER_UPP(userUPP, uppTCPNotifyProcInfo, tcpStream, eventCode,
                            userDataPtr, terminReason, icmpMsg);
  }
#else
#define InvokeTCPNotifyUPP(tcpStream, eventCode, userDataPtr, terminReason, \
                           icmpMsg, userUPP)                                \
  CALL_FIVE_PARAMETER_UPP((userUPP), uppTCPNotifyProcInfo, (tcpStream),     \
                          (eventCode), (userDataPtr), (terminReason),       \
                          (icmpMsg))
#endif
#endif
 
  void
  InvokeTCPIOCompletionUPP(TCPiopb *iopb, TCPIOCompletionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeTCPIOCompletionUPP(TCPiopb *iopb,
                                       TCPIOCompletionUPP userUPP)
  {
    CALL_ONE_PARAMETER_UPP(userUPP, uppTCPIOCompletionProcInfo, iopb);
  }
#else
#define InvokeTCPIOCompletionUPP(iopb, userUPP) \
  CALL_ONE_PARAMETER_UPP((userUPP), uppTCPIOCompletionProcInfo, (iopb))
#endif
#endif
 
  void
  InvokeUDPNotifyUPP(StreamPtr udpStream, unsigned short eventCode,
                     Ptr userDataPtr, ICMPReport *icmpMsg, UDPNotifyUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeUDPNotifyUPP(StreamPtr udpStream, unsigned short eventCode,
                                 Ptr userDataPtr, ICMPReport *icmpMsg,
                                 UDPNotifyUPP userUPP)
  {
    CALL_FOUR_PARAMETER_UPP(userUPP, uppUDPNotifyProcInfo, udpStream, eventCode,
                            userDataPtr, icmpMsg);
  }
#else
#define InvokeUDPNotifyUPP(udpStream, eventCode, userDataPtr, icmpMsg,  \
                           userUPP)                                     \
  CALL_FOUR_PARAMETER_UPP((userUPP), uppUDPNotifyProcInfo, (udpStream), \
                          (eventCode), (userDataPtr), (icmpMsg))
#endif
#endif
 
  void
  InvokeUDPIOCompletionUPP(UDPiopb *iopb, UDPIOCompletionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeUDPIOCompletionUPP(UDPiopb *iopb,
                                       UDPIOCompletionUPP userUPP)
  {
    CALL_ONE_PARAMETER_UPP(userUPP, uppUDPIOCompletionProcInfo, iopb);
  }
#else
#define InvokeUDPIOCompletionUPP(iopb, userUPP) \
  CALL_ONE_PARAMETER_UPP((userUPP), uppUDPIOCompletionProcInfo, (iopb))
#endif
#endif
 
#endif 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewGetIPIOCompletionProc(userRoutine) \
  NewGetIPIOCompletionUPP(userRoutine)
#define NewIPIOCompletionProc(userRoutine) NewIPIOCompletionUPP(userRoutine)
#define NewICMPEchoNotifyProc(userRoutine) NewICMPEchoNotifyUPP(userRoutine)
#define NewTCPNotifyProc(userRoutine) NewTCPNotifyUPP(userRoutine)
#define NewTCPIOCompletionProc(userRoutine) NewTCPIOCompletionUPP(userRoutine)
#define NewUDPNotifyProc(userRoutine) NewUDPNotifyUPP(userRoutine)
#define NewUDPIOCompletionProc(userRoutine) NewUDPIOCompletionUPP(userRoutine)
#define CallGetIPIOCompletionProc(userRoutine, iopb) \
  InvokeGetIPIOCompletionUPP(iopb, userRoutine)
#define CallIPIOCompletionProc(userRoutine, iopb) \
  InvokeIPIOCompletionUPP(iopb, userRoutine)
#define CallICMPEchoNotifyProc(userRoutine, iopb) \
  InvokeICMPEchoNotifyUPP(iopb, userRoutine)
#define CallTCPNotifyProc(userRoutine, tcpStream, eventCode, userDataPtr,      \
                          terminReason, icmpMsg)                               \
  InvokeTCPNotifyUPP(tcpStream, eventCode, userDataPtr, terminReason, icmpMsg, \
                     userRoutine)
#define CallTCPIOCompletionProc(userRoutine, iopb) \
  InvokeTCPIOCompletionUPP(iopb, userRoutine)
#define CallUDPNotifyProc(userRoutine, udpStream, eventCode, userDataPtr, \
                          icmpMsg)                                        \
  InvokeUDPNotifyUPP(udpStream, eventCode, userDataPtr, icmpMsg, userRoutine)
#define CallUDPIOCompletionProc(userRoutine, iopb) \
  InvokeUDPIOCompletionUPP(iopb, userRoutine)
#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