SocketServices.h

Go to the documentation of this file.

 
#ifndef __SOCKETSERVICES__
#define __SOCKETSERVICES__
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __MIXEDMODE__
#include <MixedMode.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
 
 
  typedef Byte SS_BYTE;
  typedef Byte SS_FLAGS8;
  typedef Byte SS_IRQ;
  typedef Byte SS_PWRLEVEL;
  typedef UInt16 SS_ADAPTER;
  typedef UInt16 SS_BCD;
  typedef UInt16 SS_COUNT;
  typedef UInt16 SS_EDC;
  typedef UInt16 SS_FLAGS16;
  typedef UInt16 SS_PAGE;
  typedef UInt16 SS_PWRINDEX;
  typedef UInt16 SS_SIGNATURE;
  typedef UInt16 SS_SKTBITS;
  typedef UInt16 SS_SOCKET;
  typedef UInt16 SS_SPEED;
  typedef UInt16 SS_WINDOW;
  typedef UInt16 SS_WORD;
  typedef UInt32 SS_BASE;
  typedef UInt32 SS_FLAGS32;
  typedef UInt32 SS_OFFSET;
  typedef UInt32 SS_SIZE;
  typedef Ptr SS_PTR;
  typedef OSErr SS_RETCODE;
  struct SS_SCHARTBL
  {
    UInt16 sktCaps;    
    UInt32 activeHigh; 
    UInt32 activeLow;  
  };
  typedef struct SS_SCHARTBL SS_SCHARTBL;
  struct SS_SISTRUCT
  {
    UInt16 bufferLength;   
    UInt16 dataLength;     
    SS_SCHARTBL charTable; 
  };
  typedef struct SS_SISTRUCT SS_SISTRUCT;
  enum
  {
    STR_SIZE = 24
  };
 
  struct SS_VISTRUCT
  {
    UInt16 bufferLength;   
    UInt16 dataLength;     
    char szImplementor[1]; 
    Byte padding[1];       
  };
  typedef struct SS_VISTRUCT SS_VISTRUCT;
  struct SS_ACHARTBL
  {
    UInt16 adpCaps;    
    UInt32 activeHigh; 
    UInt32 activeLow;  
  };
  typedef struct SS_ACHARTBL SS_ACHARTBL;
  struct SS_PWRENTRY
  {
    Byte powerLevel;   
    Byte validSignals; 
  };
  typedef struct SS_PWRENTRY SS_PWRENTRY;
  struct SS_AISTRUCT
  {
    UInt16 bufferLength; 
    UInt16 dataLength;   
    SS_ACHARTBL charTable;
    UInt16 numPwrEntries; 
    SS_PWRENTRY *pwrEntryPtr;
  };
  typedef struct SS_AISTRUCT SS_AISTRUCT;
  struct SS_MEMWINTBL
  {
    UInt16 memWndCaps; 
    UInt32 firstByte;  
    UInt32 lastByte;   
    UInt32 minSize;    
    UInt32 maxSize;    
    UInt32 reqGran;    
    UInt32 reqBase;    
    UInt32 reqOffset;  
    UInt16 slowest;    
    UInt16 fastest;    
  };
  typedef struct SS_MEMWINTBL SS_MEMWINTBL;
  struct SS_IOWINTBL
  {
    UInt16 ioWndCaps; 
    UInt32 firstByte; 
    UInt32 lastByte;  
    UInt32 minSize;   
    UInt32 maxSize;   
    UInt32 reqGran;   
    UInt16 addrLines; 
    Byte eisaSlot;    
    Byte padding[1];  
  };
  typedef struct SS_IOWINTBL SS_IOWINTBL;
  struct SS_WISTRUCT
  {
    UInt16 bufferLength;  
    UInt16 dataLength;    
    UInt16 numTblEntries; 
    SS_MEMWINTBL memWinTbl;
    SS_IOWINTBL ioWinTbl;
  };
  typedef struct SS_WISTRUCT SS_WISTRUCT;
 
  enum
  {
    fnSSGetAdapterCount = 0x80,
    fnSSUnsupported81 = 0x81,
    fnSSUnsupported82 = 0x82,
    fnSSGetSSInfo = 0x83,
    fnSSInquireAdapter = 0x84,
    fnSSGetAdapter = 0x85,
    fnSSSetAdapter = 0x86,
    fnSSInquireWindow = 0x87,
    fnSSGetWindow = 0x88,
    fnSSSetWindow = 0x89,
    fnSSGetPage = 0x8A,
    fnSSSetPage = 0x8B,
    fnSSInquireSocket = 0x8C,
    fnSSGetSocket = 0x8D,
    fnSSSetSocket = 0x8E,
    fnSSGetStatus = 0x8F,
    fnSSResetSocket = 0x90,
    fnSSUnsupported91 = 0x91,
    fnSSUnsupported92 = 0x92,
    fnSSUnsupported93 = 0x93,
    fnSSUnsupported94 = 0x94,
    fnSSInquireEDC = 0x95,
    fnSSGetEDC = 0x96,
    fnSSSetEDC = 0x97,
    fnSSStartEDC = 0x98,
    fnSSPauseEDC = 0x99,
    fnSSResumeEDC = 0x9A,
    fnSSStopEDC = 0x9B,
    fnSSReadEDC = 0x9C,
    fnSSGetVendorInfo = 0x9D,
    fnSSAcknowledgeInterrupt = 0x9E,
    fnSSGetSetPriorHandler = 0x9F,
    fnSSGetSetSSAddr = 0xA0,
    fnSSGetAccessOffsets = 0xA1,
    fnSSUnsupportedA2 = 0xA2,
    fnSSUnsupportedA3 = 0xA3,
    fnSSUnsupportedA4 = 0xA4,
    fnSSUnsupportedA5 = 0xA5,
    fnSSUnsupportedA6 = 0xA6,
    fnSSUnsupportedA7 = 0xA7,
    fnSSUnsupportedA8 = 0xA8,
    fnSSUnsupportedA9 = 0xA9,
    fnSSUnsupportedAA = 0xAA,
    fnSSUnsupportedAB = 0xAB,
    fnSSUnsupportedAC = 0xAC,
    fnSSUnsupportedAD = 0xAD,
    fnSSVendorSpecific = 0xAE
  };
 
  enum
  {
    fnVSReserved = 0x00,
    fnVSGetSocketLocationIcon = 0x01,
    fnVSGetSocketLocationText = 0x02,
    fnVSDoSocketLocalization = 0x03,
    fnVSAppleSocketCapabilities = 0x04,
    fnVSSleepWakeNotification = 0x05
  };
 
  enum
  {
    AC_IND = 1, 
    AC_PWR = 2,
    AC_DBW = 4
  };
 
  enum
  {
    AS_POWERDOWN = 1,
    AS_MAINTAIN = 2
  };
 
  enum
  {
    EC_UNI = 1,
    EC_BI = 2,
    EC_REGISTER = 4,
    EC_MEMORY = 8,
    EC_PAUSABLE = 16,
    EC_WRITE = 16
  };
 
  enum
  {
    ET_CHECK8 = 1,
    ET_SDLC16 = 2
  };
 
  enum
  {
    IF_MEMORY = 1,
    IF_IO = 2
  };
 
  enum
  {
    IRQ_HIGH = 64,
    IRQ_ENABLE = 128
  };
 
  enum
  {
    IRQ_MEMORY = 4,
    IRQ_IO = 4
  };
 
  enum
  {
    PS_ATTRIBUTE = 0x01,
    PS_ENABLED = 0x02,
    PS_WP = 0x04
  };
 
  enum
  {
    PWR_VCC = 128, 
    PWR_VPP1 = 64,
    PWR_VPP2 = 32
  };
 
  enum
  {
    SBM_WP = 1,
    SBM_LOCKED = 2,
    SBM_EJECT = 4,
    SBM_INSERT = 8,
    SBM_BVD1 = 16,
    SBM_BVD2 = 32,
    SBM_RDYBSY = 64,
    SBM_CD = 128
  };
 
  enum
  {
    SBM_LOCK = 16,
    SBM_BATT = 32,
    SBM_BUSY = 64,
    SBM_XIP = 128
  };
 
  enum
  {
    SBM_SLEEP_PWR = 1
  };
 
  enum
  {
    WC_COMMON = 1,
    WC_IO = 2,
    WC_ATTRIBUTE = 4,
    WC_TYPE_MASK = 7,
    WC_WAIT = 128
  };
 
  enum
  {
    WC_BASE = 1,
    WC_SIZE = 2,
    WC_WENABLE = 4,
    WC_8BIT = 8,
    WC_16BIT = 16,
    WC_BALIGN = 32,
    WC_POW2 = 64,
    WC_CALIGN = 128,
    WC_PAVAIL = 256,
    WC_PSHARED = 512,
    WC_PENABLE = 1024,
    WC_WP = 2048
  };
 
  enum
  {
    WC_INPACK = 128,
    WC_EISA = 256,
    WC_CENABLE = 512
  };
 
  enum
  {
    WS_IO = 1,
    WS_ENABLED = 2,
    WS_16BIT = 4
  };
 
  enum
  {
    WS_PAGED = 8,
    WS_EISA = 16,
    WS_CENABLE = 32,
    WS_SWAP_LITTLE_TO_BIG_ENDIAN = 64
  };
 
  enum
  {
    SS_SIG_VALUE = 0x5353 
  };
 
  enum
  {
    SS_CMPL_1_00 = 0x0100, 
    SS_CMPL_1_01 = 0x0101, 
    SS_CMPL_2_00 = 0x0200, 
    SS_CMPL_2_10 = 0x0210  
  };
 
  typedef CALLBACK_API(short, PCCardSSEntryProcPtr)(UInt16 fnCode, Ptr callPB,
                                                    Ptr dataPtr);
  typedef STACK_UPP_TYPE(PCCardSSEntryProcPtr) PCCardSSEntryUPP;
#if CALL_NOT_IN_CARBON
  PCCardSSEntryUPP
  NewPCCardSSEntryUPP(PCCardSSEntryProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppPCCardSSEntryProcInfo = 0x00000FA0
  }; 
#ifdef __cplusplus
  inline PCCardSSEntryUPP NewPCCardSSEntryUPP(PCCardSSEntryProcPtr userRoutine)
  {
    return (PCCardSSEntryUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                  uppPCCardSSEntryProcInfo,
                                                  GetCurrentArchitecture());
  }
#else
#define NewPCCardSSEntryUPP(userRoutine)                                     \
  (PCCardSSEntryUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppPCCardSSEntryProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposePCCardSSEntryUPP(PCCardSSEntryUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposePCCardSSEntryUPP(PCCardSSEntryUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposePCCardSSEntryUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  short
  InvokePCCardSSEntryUPP(UInt16 fnCode, Ptr callPB, Ptr dataPtr,
                         PCCardSSEntryUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline short InvokePCCardSSEntryUPP(UInt16 fnCode, Ptr callPB, Ptr dataPtr,
                                      PCCardSSEntryUPP userUPP)
  {
    return (short)CALL_THREE_PARAMETER_UPP(userUPP, uppPCCardSSEntryProcInfo,
                                           fnCode, callPB, dataPtr);
  }
#else
#define InvokePCCardSSEntryUPP(fnCode, callPB, dataPtr, userUPP)       \
  (short)CALL_THREE_PARAMETER_UPP((userUPP), uppPCCardSSEntryProcInfo, \
                                  (fnCode), (callPB), (dataPtr))
#endif
#endif
 
#endif 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewPCCardSSEntryProc(userRoutine) NewPCCardSSEntryUPP(userRoutine)
#define CallPCCardSSEntryProc(userRoutine, fnCode, callPB, dataPtr) \
  InvokePCCardSSEntryUPP(fnCode, callPB, dataPtr, userRoutine)
#endif 
  struct CSEventEntryPB
  {
    UInt32 ssHandlerID;
    UInt16 adapter;
    UInt16 socket;
    UInt16 message;
    Byte intrpBits;
    Byte padding;
  };
  typedef struct CSEventEntryPB CSEventEntryPB;
  typedef CALLBACK_API(void, PCCardCSEntryProcPtr)(CSEventEntryPB *pb);
  typedef STACK_UPP_TYPE(PCCardCSEntryProcPtr) PCCardCSEntryUPP;
#if CALL_NOT_IN_CARBON
  PCCardCSEntryUPP
  NewPCCardCSEntryUPP(PCCardCSEntryProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppPCCardCSEntryProcInfo = 0x000000C0
  }; 
#ifdef __cplusplus
  inline PCCardCSEntryUPP NewPCCardCSEntryUPP(PCCardCSEntryProcPtr userRoutine)
  {
    return (PCCardCSEntryUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                  uppPCCardCSEntryProcInfo,
                                                  GetCurrentArchitecture());
  }
#else
#define NewPCCardCSEntryUPP(userRoutine)                                     \
  (PCCardCSEntryUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppPCCardCSEntryProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposePCCardCSEntryUPP(PCCardCSEntryUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposePCCardCSEntryUPP(PCCardCSEntryUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposePCCardCSEntryUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  InvokePCCardCSEntryUPP(CSEventEntryPB *pb, PCCardCSEntryUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokePCCardCSEntryUPP(CSEventEntryPB *pb,
                                     PCCardCSEntryUPP userUPP)
  {
    CALL_ONE_PARAMETER_UPP(userUPP, uppPCCardCSEntryProcInfo, pb);
  }
#else
#define InvokePCCardCSEntryUPP(pb, userUPP) \
  CALL_ONE_PARAMETER_UPP((userUPP), uppPCCardCSEntryProcInfo, (pb))
#endif
#endif
 
#endif 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewPCCardCSEntryProc(userRoutine) NewPCCardCSEntryUPP(userRoutine)
#define CallPCCardCSEntryProc(userRoutine, pb) \
  InvokePCCardCSEntryUPP(pb, userRoutine)
#endif 
  struct AddSocketServicesPB
  {
    PCCardSSEntryUPP ssEntry; 
    PCCardCSEntryUPP csEntry; 
    UInt32 dataPtr;
    UInt32 attributes;
    UInt16 numAdapters;
    UInt16 numSockets;
  };
  typedef struct AddSocketServicesPB AddSocketServicesPB;
  struct ReplaceSocketServicesPB
  {
    PCCardSSEntryUPP ssEntry;
    PCCardSSEntryUPP oldSSEntry;
 
    UInt32 dataPtr;
    UInt16 socket;
    UInt16 numSockets;
    UInt16 attributes;
  };
  typedef struct ReplaceSocketServicesPB ReplaceSocketServicesPB;
#if CALL_NOT_IN_CARBON
  OSErr
  CSAddSocketServices(AddSocketServicesPB *pb);
 
  OSErr
  CSReplaceSocketServices(ReplaceSocketServicesPB *pb);
 
#endif 
  struct SSAcknowledgeInterruptPB
  {
    UInt16 adapter; 
    UInt16 sockets; 
  };
  typedef struct SSAcknowledgeInterruptPB SSAcknowledgeInterruptPB;
  struct SSGetAccessOffsetsPB
  {
    UInt16 adapter;  
    Byte mode;       
    Byte reserved;   
    UInt16 count;    
    Ptr buffer;      
    UInt16 numAvail; 
  };
  typedef struct SSGetAccessOffsetsPB SSGetAccessOffsetsPB;
  struct SSGetAdapterCountPB
  {
    UInt16 totalAdapters; 
    UInt16 sig;           
  };
  typedef struct SSGetAdapterCountPB SSGetAdapterCountPB;
  struct SSGetSetAdapterPB
  {
    UInt16 adapter; 
    Byte state;     
    Byte irqStatus; 
  };
  typedef struct SSGetSetAdapterPB SSGetSetAdapterPB;
  struct SSGetSetEDCPB
  {
    UInt16 adapter; 
    UInt16 edc;     
    UInt16 socket;  
    Byte state;     
    Byte edcType;   
  };
  typedef struct SSGetSetEDCPB SSGetSetEDCPB;
  struct SSGetSetPagePB
  {
    UInt16 adapter; 
    UInt16 window;  
    UInt16 page;    
    Byte state;     
    Byte reserved;  
    UInt32 offset;  
  };
  typedef struct SSGetSetPagePB SSGetSetPagePB;
  struct SSGetSetPriorHandlerPB
  {
    UInt16 adapter; 
    Byte mode;      
    Byte reserved;  
    Ptr handler;    
  };
  typedef struct SSGetSetPriorHandlerPB SSGetSetPriorHandlerPB;
  struct SSGetSetSocketPB
  {
    UInt16 adapter;   
    UInt16 socket;    
    UInt16 vccIndex;  
    UInt16 vpp1Index; 
    UInt16 vpp2Index; 
    Byte scIntMask;   
    Byte state;       
    Byte ctlInd;      
    Byte ireqRouting; 
    Byte ifType;      
    Byte padding[1];  
  };
  typedef struct SSGetSetSocketPB SSGetSetSocketPB;
  struct SSGetSetSSAddrPB
  {
    UInt16 adapter;    
    Byte mode;         
    Byte subfunc;      
    UInt16 numAddData; 
    Ptr buffer;        
  };
  typedef struct SSGetSetSSAddrPB SSGetSetSSAddrPB;
  struct SSGetSetWindowPB
  {
    UInt16 adapter; 
    UInt16 window;  
    UInt16 socket;  
    UInt32 size;    
    Byte state;     
    Byte reserved;  
    UInt16 speed;   
    UInt32 base;    
  };
  typedef struct SSGetSetWindowPB SSGetSetWindowPB;
  struct SSGetSSInfoPB
  {
    UInt16 adapter;      
    UInt16 compliance;   
    UInt16 numAdapters;  
    UInt16 firstAdapter; 
  };
  typedef struct SSGetSSInfoPB SSGetSSInfoPB;
  struct SSGetStatusPB
  {
    UInt16 adapter;   
    UInt16 socket;    
    Byte cardState;   
    Byte socketState; 
    Byte ctlInd;      
    Byte ireqRouting; 
    Byte ifType;      
    Byte padding[1];  
  };
  typedef struct SSGetStatusPB SSGetStatusPB;
  struct SSGetVendorInfoPB
  {
    UInt16 adapter;      
    Byte vendorInfoType; 
    Byte reserved;       
    Ptr buffer;          
    UInt16 release;      
  };
  typedef struct SSGetVendorInfoPB SSGetVendorInfoPB;
  struct SSInquireAdapterPB
  {
    UInt16 adapter;    
    Ptr buffer;        
    UInt16 numSockets; 
    UInt16 numWindows; 
    UInt16 numEDCs;    
  };
  typedef struct SSInquireAdapterPB SSInquireAdapterPB;
  struct SSInquireEDCPB
  {
    UInt16 adapter; 
    UInt16 edc;     
    UInt16 sockets; 
    Byte caps;      
    Byte types;     
  };
  typedef struct SSInquireEDCPB SSInquireEDCPB;
  struct SSInquireSocketPB
  {
    UInt16 adapter;  
    UInt16 socket;   
    Ptr buffer;      
    Byte scIntCaps;  
    Byte scRptCaps;  
    Byte ctlIndCaps; 
    Byte padding[1]; 
  };
  typedef struct SSInquireSocketPB SSInquireSocketPB;
  struct SSInquireWindowPB
  {
    UInt16 adapter; 
    UInt16 window;  
    Ptr buffer;     
    Byte wndCaps;   
    Byte reserved;  
    UInt16 sockets; 
  };
  typedef struct SSInquireWindowPB SSInquireWindowPB;
  struct SSPauseEDCPB
  {
    UInt16 adapter; 
    UInt16 edc;     
  };
  typedef struct SSPauseEDCPB SSPauseEDCPB;
  struct SSReadEDCPB
  {
    UInt16 adapter; 
    UInt16 edc;     
    UInt16 value;   
  };
  typedef struct SSReadEDCPB SSReadEDCPB;
  struct SSResetSocketPB
  {
    UInt16 adapter; 
    UInt16 socket;  
  };
  typedef struct SSResetSocketPB SSResetSocketPB;
  struct SSResumeEDCPB
  {
    UInt16 adapter; 
    UInt16 edc;     
  };
  typedef struct SSResumeEDCPB SSResumeEDCPB;
  struct SSStartEDCPB
  {
    UInt16 adapter; 
    UInt16 edc;     
  };
  typedef struct SSStartEDCPB SSStartEDCPB;
  struct SSStopEDCPB
  {
    UInt16 adapter; 
    UInt16 edc;     
  };
  typedef struct SSStopEDCPB SSStopEDCPB;
  struct SSVendorSpecificPB
  {
    UInt16 vsFunction; 
    UInt16 adapter;    
    UInt16 socket;     
    UInt16 bufferSize; 
    Ptr buffer;        
    UInt32 attributes; 
  };
  typedef struct SSVendorSpecificPB SSVendorSpecificPB;
  enum
  {
    kSSGoingToSleep = 0x00000001,
    kSSWakingFromSleep = 0x00000002
  };
 
#if CALL_NOT_IN_CARBON
  SS_RETCODE
  SSGetAdapterCount(SSGetAdapterCountPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSAcknowledgeInterrupt(SSAcknowledgeInterruptPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSGetSetPriorHandler(SSGetSetPriorHandlerPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSGetSetSSAddr(SSGetSetSSAddrPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSGetAccessOffsets(SSGetAccessOffsetsPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSGetAdapter(SSGetSetAdapterPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSGetSSInfo(SSGetSSInfoPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSGetVendorInfo(SSGetVendorInfoPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSInquireAdapter(SSInquireAdapterPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSSetAdapter(SSGetSetAdapterPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSVendorSpecific(SSVendorSpecificPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSGetSocket(SSGetSetSocketPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSGetStatus(SSGetStatusPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSInquireSocket(SSInquireSocketPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSResetSocket(SSResetSocketPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSSetSocket(SSGetSetSocketPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSGetPage(SSGetSetPagePB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSGetWindow(SSGetSetWindowPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSInquireWindow(SSInquireWindowPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSSetPage(SSGetSetPagePB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSSetWindow(SSGetSetWindowPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSGetEDC(SSGetSetEDCPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSInquireEDC(SSInquireEDCPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSPauseEDC(SSPauseEDCPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSReadEDC(SSReadEDCPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSResumeEDC(SSResumeEDCPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSSetEDC(SSGetSetEDCPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSStartEDC(SSStartEDCPB *pb, Ptr dataPtr);
 
  SS_RETCODE
  SSStopEDC(SSStopEDCPB *pb, Ptr dataPtr);
 
#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