Legacy Mac OS X Reference Library Apple Developer Connection

Open Transport Reference

Framework
CoreServices/CoreServices.h
Declared in
OpenTransport.h
OpenTransportProtocol.h
OpenTransportProviders.h
queue.h
types.h

Overview

Open Transport is the Mac OS 8 and 9 API for accessing TCP/IP networks, such as the Internet, at the transport level. For Mac OS X, Apple provides Open Transport as a compatibility library to ease migration of legacy applications. As such, Mac OS X does not support the entire Open Transport API.

In new Mac OS X applications you should not use Open Transport but should instead use BSD Sockets or, when possible, higher-level Core Services and Core Foundation APIs such as CFNetwork, CFURL, CFSocket, and CFStream. You can also use Cocoa networking classes such as NSURL, NSURLHandle, and NSNetService.

In Mac OS X, Open Transport provides limited support for endpoints and port access, and no support for the XTI or UNIX STREAMS interfaces. If you want your application to run in Mac OS 8 and 9 and in Mac OS X, use Open Transport for your Mac OS 8 and 9 version and Apple’s newer APIs for your Mac OS X version.

For more information about Open Transport, see:

http://developer.apple.com/macos/opentransport/

Mac OS X supports only these Open Transport providers:

Mac OS X does not support ADSP, ATP, ASP, PAP, or serial endpoints.

You may have to revise your code if it uses Open Transport in one of the following ways:

Mac OS X does not support functions for:

Client context parameters have been added to a number of OT functions. (An OT client is an application or a shared library.) Each client of Open Transport now has its own client context so that OT can track resources it allocates on behalf of the client. OT resources are objects like endpoints, timer tasks, and blocks of memory. To find out more about Open Transport resources management, see “Understanding Open Transport Asset Tracking” at:

http://developer.apple.com/technotes/tn/tn1173.html

Mac OS X introduces a new type, OTClientContextPtr, that represents the OT client context. This new type is passed as an extra parameter to functions that allocate OT resources. Before Mac OS X, the OT client context was determined by the Open Transport static libraries that you linked to your application. Now the OT client context is determined explicitly. The same Carbon binary can run on Mac OS 8/9 and Mac OS X, and you do not have to link your application to the static libraries.

You can use InitOpenTransportinContext to replace InitOpenTransport. It functions identically except that it also takes a client context pointer and a flags parameter to indicate whether you are initializing OT for an application or a shared library. When your application or shared library is done using Open Transport you should call CloseOpenTransportInContext to dispose of the Open Transport resources allocated for the client.

The following functions now take a client context:

As a convenience, applications may pass a null pointer to these routines and Open Transport will use the context that was passed to InitOpenTransport. However, shared libraries must always pass a valid OTClientContextPtr.

If you want to keep your application source code compatible with pre-Mac OS X systems, you may define the C preprocessor constant OTCARBONAPPLICATION to 1 to use the old routine names without the “InContext” suffix.

Mac OS X applications must pass UPPs instead of procedure pointers for Open Transport callback routines. You can use these new functions to create UPPs:

OTNotifyUPP replaces OTNotifyProcPtr

OTProcessUPP replaces OTNotifyProcPtr

OTListSearchUPP replaces OTListSearchProcPtr

You can use these functions to allocate and free UPPs:

These functions have been modified to take an OTNotifyUPP UPP instead of a procedure pointer:

These functions have been modified to take an OTProcessUPP UPP instead of a procedure pointer:

These functions have been modified to take an OTListSearchUPP UPP instead of a procedure pointer:

Functions by Task

Initializing and Closing Open Transport

Creating, Cloning, and Disposing of a Configuration Structure

Opening and Closing Providers

Controlling a Provider’s Modes of Operation

Using Notifier Functions with Providers

Sending Module-Specific Commands to Providers

Creating Endpoints

Binding and Unbinding Endpoints

Obtaining Information About an Endpoint

Allocating Structures for Endpoints

Determining if Bytes Are Available for Endpoints

Functions for Connectionless Transactionless Endpoints

Establishing Connection for Endpoints

Functions for Connection-Oriented Transactionless Endpoints

Tearing Down an Endpoint Connection

Checking Synchronous Calls

Working With Timer Tasks

Working With Deferred Tasks

Creating Mappers

Registering and Deleting Names with Mappers

Looking Up Names for Mappers

Determining and Changing Option Values

Finding Options

Getting Information About Ports

Registering New Ports

Registering as a Client

Allocating and Freeing Memory

Memory Manipulation Utility Functions

Idling and Delaying Processing

String Manipulation Utility Functions

Timestamp Utility Functions

OTLIFO List Utility Functions

OTFIFO List Utility Functions

Adding and Removing List Elements

Atomic Operations

Handling No-Copy Receives

Resolving Internet Addresses

Opening a TCP/IP Service Provider

Getting Information About an Internet Host

Retrieving DNS Query Information

Internet Address Utilities

Single Link Multi-Homing

AppleTalk Utility Functions

Opening an AppleTalk Service Provider

Obtaining Information About Zones

Obtaining Information About Your AppleTalk Environment

Miscellaneous Functions

Callbacks by Task

Notifier Callbacks

System, Timer, and Deferred Task Callbacks

Linked List Callbacks

Miscellaneous Callbacks

Callbacks

admin_t

typedef OTInt32 (*admin_t) ();

If you name your function MyAdmin_tCallback, you would declare it like this:

OTInt32 MyAdmin_tCallback ();

Parameters
Return Value

See the description of the OTInt32 data type.

Carbon Porting Notes

Carbon does not support any STREAMS functionality because the STREAMS subsystem is not available on Mac OS X.

bufcallp_t

typedef void (*bufcallp_t) (
   SInt32 size
);

If you name your function MyBufcallp_tCallback, you would declare it like this:

void MyBufcallp_tCallback (
   SInt32 size
);

Parameters
size
Carbon Porting Notes

Carbon does not support any STREAMS functionality because the STREAMS subsystem is not available on Mac OS X.

bufcall_t

typedef void (*bufcall_t) (
   SInt32 size
);

If you name your function MyBufcall_tCallback, you would declare it like this:

void MyBufcall_tCallback (
   SInt32 size
);

Parameters
size
Carbon Porting Notes

Carbon does not support any STREAMS functionality because the STREAMS subsystem is not available on Mac OS X.

closeOld_t

typedef OTInt32 (*closeOld_t) (
   queue *q
);

If you name your function MyCloseOld_tCallback, you would declare it like this:

OTInt32 MyCloseOld_tCallback (
   queue *q
);

Parameters
q
Return Value

See the description of the OTInt32 data type.

Carbon Porting Notes

Carbon does not support any STREAMS functionality because the STREAMS subsystem is not available on Mac OS X.

closep_t

typedef OTInt32 (*closep_t) (
   queue *q,
   OTInt32 foo,
   cred_t *cred
);

If you name your function MyClosep_tCallback, you would declare it like this:

OTInt32 MyClosep_tCallback (
   queue *q,
   OTInt32 foo,
   cred_t *cred
);

Parameters
q
foo
cred
Return Value

See the description of the OTInt32 data type.

Carbon Porting Notes

Carbon does not support Open Transport configuration APIs because the Mac OS X networking stack is not based on STREAMS.

esbbcallProc

typedef void (*esbbcallProc) (
   SInt32 arg
);

If you name your function MyEsbbcallCallback, you would declare it like this:

void MyEsbbcallCallback (
   SInt32 arg
);

Parameters
arg
Carbon Porting Notes

This function is not needed in Carbon because the STREAMS subsystem is not available on Mac OS X.

FreeFuncType

typedef void (*FreeFuncType) (
   char *arg
);

If you name your function MyFreeFuncTypeCallback, you would declare it like this:

void MyFreeFuncTypeCallback (
   char *arg
);

Parameters
arg
Carbon Porting Notes

This function is not needed in Carbon because the STREAMS subsystem is not available on Mac OS X.

old_closep_t

typedef OTInt32 (*old_closep_t) (
   queue *q
);

If you name your function MyOld_closep_tCallback, you would declare it like this:

OTInt32 MyOld_closep_tCallback (
   queue *q
);

Parameters
q
Return Value

See the description of the OTInt32 data type.

Carbon Porting Notes

Carbon does not support any STREAMS functionality because the STREAMS subsystem is not available on Mac OS X.

old_openp_t

typedef OTInt32 (*old_openp_t) (
   queue *q,
   dev_t dev,
   OTInt32 foo,
   OTInt32 bar
);

If you name your function MyOld_openp_tCallback, you would declare it like this:

OTInt32 MyOld_openp_tCallback (
   queue *q,
   dev_t dev,
   OTInt32 foo,
   OTInt32 bar
);

Parameters
q
dev
foo
bar
Return Value

See the description of the OTInt32 data type.

Carbon Porting Notes

Carbon does not support any STREAMS functionality because the STREAMS subsystem is not available on Mac OS X.

openOld_t

typedef OTInt32 (*openOld_t) (
   queue *q,
   dev_t dev,
   OTInt32 foo,
   OTInt32 bar
);

If you name your function MyOpenOld_tCallback, you would declare it like this:

OTInt32 MyOpenOld_tCallback (
   queue *q,
   dev_t dev,
   OTInt32 foo,
   OTInt32 bar
);

Parameters
q
dev
foo
bar
Return Value

See the description of the OTInt32 data type.

Carbon Porting Notes

Carbon does not support any STREAMS functionality because the STREAMS subsystem is not available on Mac OS X.

openp_t

typedef OTInt32 (*openp_t) (
   queue *q,
   dev_t *dev,
   OTInt32 foo,
   OTInt32 bar,
   cred_t *cred
);

If you name your function MyOpenp_tCallback, you would declare it like this:

OTInt32 MyOpenp_tCallback (
   queue *q,
   dev_t *dev,
   OTInt32 foo,
   OTInt32 bar,
   cred_t *cred
);

Parameters
q
dev
foo
bar
cred
Return Value

See the description of the OTInt32 data type.

Carbon Porting Notes

Carbon does not support any STREAMS functionality because the STREAMS subsystem is not available on Mac OS X.

OTAllocMemProcPtr

typedef void (*OTAllocMemProcPtr) (
   OTByteCount size
);

If you name your function MyOTAllocMemProc, you would declare it like this:

void MyOTAllocMemProc (
   OTByteCount size
);

Parameters
size
Carbon Porting Notes

Carbon does not support any STREAMS functionality because the STREAMS subsystem is not available on Mac OS X.

OTCanConfigureProcPtr

typedef Boolean (*OTCanConfigureProcPtr)
(
   OTConfigurationRef cfig,
   UInt32 pass
);

If you name your function MyOTCanConfigureProc, you would declare it like this:

Boolean MyOTCanConfigureProc (
   OTConfigurationRef cfig,
   UInt32 pass
);

Parameters
cfig
pass
Carbon Porting Notes

Carbon does not support access to Open Transport configuration APIs because the Mac OS X networking stack is not based on STREAMS.

OTCFConfigureProcPtr

typedef OSStatus (*OTCFConfigureProcPtr)
(
   TOTConfiguratorRef cfigor,
   OTConfigurationRef cfig
);

If you name your function MyOTCFConfigureProc, you would declare it like this:

OSStatus MyOTCFConfigureProc (
   TOTConfiguratorRef cfigor,
   OTConfigurationRef cfig
);

Parameters
cfigor
cfig
Return Value

A result code. See “Open Transport Result Codes.”

Carbon Porting Notes

Carbon does not support access to Open Transport configuration APIs because the Mac OS X networking stack is not based on STREAMS.

OTCFCreateStreamProcPtr

typedef OSStatus (*OTCFCreateStreamProcPtr)
(
   TOTConfiguratorRef cfigor,
   OTConfigurationRef cfig,
   OTOpenFlags oFlags,
   OTNotifyUPP proc,
   void *contextPtr
);

If you name your function MyOTCFCreateStreamProc, you would declare it like this:

OSStatus MyOTCFCreateStreamProc (
   TOTConfiguratorRef cfigor,
   OTConfigurationRef cfig,
   OTOpenFlags oFlags,
   OTNotifyUPP proc,
   void *contextPtr
);

Parameters
cfigor
cfig
oFlags
proc
contextPtr
Return Value

A result code. See “Open Transport Result Codes.”

Carbon Porting Notes

Carbon does not support access to Open Transport configuration APIs because the Mac OS X networking stack is not based on STREAMS.

OTCFHandleSystemEventProcPtr

typedef void (*OTCFHandleSystemEventProcPtr)
(
   TOTConfiguratorRef cfigor,
   OTEventCode code,
   OTResult result,
   void *cookie
);

If you name your function MyOTCFHandleSystemEventProc, you would declare it like this:

void MyOTCFHandleSystemEventProc (
   TOTConfiguratorRef cfigor,
   OTEventCode code,
   OTResult result,
   void *cookie
);

Parameters
cfigor
code
result
cookie
Carbon Porting Notes

Carbon does not support access to Open Transport configuration APIs because the Mac OS X networking stack is not based on STREAMS.

OTCreateConfiguratorProcPtr

typedef OSStatus (*OTCreateConfiguratorProcPtr)
(
   TOTConfiguratorRef *cfigor
);

If you name your function MyOTCreateConfiguratorProc, you would declare it like this:

OSStatus MyOTCreateConfiguratorProc (
   TOTConfiguratorRef *cfigor
);

Parameters
cfigor
Return Value

A result code. See “Open Transport Result Codes.”

Carbon Porting Notes

Carbon does not support access to Open Transport configuration APIs because the Mac OS X networking stack is not based on STREAMS.

OTGateProcPtr

typedef Boolean (*OTGateProcPtr) (
   OTLink *thisLink
);

If you name your function MyOTGateProc, you would declare it like this:

Boolean MyOTGateProc (
   OTLink *thisLink
);

Parameters
thisLink
Carbon Porting Notes

Carbon does not support Open Transport configuration APIs because the Mac OS X networking stack is not based on STREAMS.

Availability
Declared In
OpenTransportProtocol.h

OTGetPortIconProcPtr

typedef Boolean (*OTGetPortIconProcPtr)
(
   OTPortRecord *port,
   OTResourceLocator *iconLocation
);

If you name your function MyOTGetPortIconProc, you would declare it like this:

Boolean MyOTGetPortIconProc (
   OTPortRecord *port,
   OTResourceLocator *iconLocation
);

Parameters
port
iconLocation
Carbon Porting Notes

Carbon does not support access to the Open Transport port name or icon because this information is not available on Mac OS X.

OTGetPortNameProcPtr

typedef void (*OTGetPortNameProcPtr)
(
   OTPortRecord *port,
   OTBooleanParam includeSlot,
   OTBooleanParam includePort,
   Str255 userVisibleName
);

If you name your function MyOTGetPortNameProc, you would declare it like this:

void MyOTGetPortNameProc (
   OTPortRecord *port,
   OTBooleanParam includeSlot,
   OTBooleanParam includePort,
   Str255 userVisibleName
);

Parameters
port
includeSlot
includePort
userVisibleName
Carbon Porting Notes

Carbon does not support access to the Open Transport port name or icon because this information is not available on Mac OS X.

OTHashProcPtr

typedef UInt32 (*OTHashProcPtr) (
   OTLink *linkToHash
);

If you name your function MyOTHashProc, you would declare it like this:

UInt32 MyOTHashProc (
   OTLink *linkToHash
);

Parameters
linkToHash
Carbon Porting Notes

Carbon does not support Open Transport hash lists because Apple has not identified a developer need for them.

Availability
Declared In
OpenTransportProtocol.h

OTHashSearchProcPtr

typedef Boolean (*OTHashSearchProcPtr)
(
   const void *ref,
   OTLink *linkToCheck
);

If you name your function MyOTHashSearchProc, you would declare it like this:

Boolean MyOTHashSearchProc (
   const void *ref,
   OTLink *linkToCheck
);

Parameters
ref
linkToCheck
Carbon Porting Notes

Carbon does not support Open Transport hash lists because Apple has not identified a developer need for them.

Availability
Declared In
OpenTransportProtocol.h

OTListSearchProcPtr

typedef Boolean (*OTListSearchProcPtr)
(
   const void *ref,
   OTLink *linkToCheck
);

If you name your function MyOTListSearchProc, you would declare it like this:

Boolean MyOTListSearchProc (
   const void *ref,
   OTLink *linkToCheck
);

Parameters
ref
linkToCheck
Carbon Porting Notes

This is a function type for a user callback. Use the type OTListSearchUPP instead.

Availability
Declared In
OpenTransport.h

OTNotifyProcPtr

typedef void (*OTNotifyProcPtr) (
   void *contextPtr,
   OTEventCode code,
   OTResult result,
   void *cookie
);

If you name your function MyOTNotifyProc, you would declare it like this:

void MyOTNotifyProc (
   void *contextPtr,
   OTEventCode code,
   OTResult result,
   void *cookie
);

Parameters
contextPtr
code
result
cookie
Carbon Porting Notes

This is a function type for a callback. Use the type OTNotifyUPP instead.

Availability
Declared In
OpenTransport.h

OTProcessProcPtr

typedef void (*OTProcessProcPtr) (
   void *arg
);

If you name your function MyOTProcessProc, you would declare it like this:

void MyOTProcessProc (
   void *arg
);

Parameters
arg
Carbon Porting Notes

Use the OTProcessUPP type instead.

Availability
Declared In
OpenTransport.h

OTSetupConfiguratorProcPtr

typedef OSStatus (*OTSetupConfiguratorProcPtr)
(
   OTCanConfigureProcPtr *canConfigure,
   OTCreateConfiguratorProcPtr *createConfigurator,
   UInt8 *configuratorType
);

If you name your function MyOTSetupConfiguratorProc, you would declare it like this:

OSStatus MyOTSetupConfiguratorProc (
   OTCanConfigureProcPtr *canConfigure,
   OTCreateConfiguratorProcPtr *createConfigurator,
   UInt8 *configuratorType
);

Parameters
canConfigure
createConfigurator
configuratorType
Return Value

A result code. See “Open Transport Result Codes.”

Carbon Porting Notes

Carbon does not support Open Transport configuration APIs because the Mac OS X networking stack is not based on STREAMS.

OTSMCompleteProcPtr

typedef void (*OTSMCompleteProcPtr) (
   void *contextPtr
);

If you name your function MyOTSMCompleteProc, you would declare it like this:

void MyOTSMCompleteProc (
   void *contextPtr
);

Parameters
contextPtr
Carbon Porting Notes

Carbon does not support Open Transport configuration APIs because the Mac OS X networking stack is not based on STREAMS.

OTStateProcPtr

typedef void (*OTStateProcPtr) (
   OTStateMachine *sm
);

If you name your function MyOTStateProc, you would declare it like this:

void MyOTStateProc (
   OTStateMachine *sm
);

Parameters
sm
Carbon Porting Notes

Carbon does not support Open Transport configuration APIs because the Mac OS X networking stack is not based on STREAMS.

putp_t

typedef OTInt32 (*putp_t) (
   queue *q,
   msgb *mp
);

If you name your function MyPutp_tCallback, you would declare it like this:

OTInt32 MyPutp_tCallback (
   queue *q,
   msgb *mp
);

Parameters
q
mp
Return Value

See the description of the OTInt32 data type.

Carbon Porting Notes

Carbon does not support any STREAMS functionality because the STREAMS subsystem is not available on Mac OS X.

srvp_t

typedef OTInt32 (*srvp_t) (
   queue *q
);

If you name your function MySrvp_tCallback, you would declare it like this:

OTInt32 MySrvp_tCallback (
   queue *q
);

Parameters
q
Return Value

See the description of the OTInt32 data type.

Carbon Porting Notes

Carbon does not support any STREAMS functionality because the STREAMS subsystem is not available on Mac OS X.

Data Types

AppleTalkInfo

Obtain informations about the current AppleTalk environment.

struct AppleTalkInfo {
   DDPAddress fOurAddress;
   DDPAddress fRouterAddress;
   UInt16 fCableRange[2];
   UInt16 fFlags;
};
typedef struct AppleTalkInfo AppleTalkInfo;
Fields
fOurAddress

The network number and node ID of your node.

fRouterAddress

The network number and node ID of the closest router on your network.

fCableRange

A two-element array indicating the first and last network numbers for the current extended network to which the machine is connected. For nonextended networks, this returns the name of the zone.

fFlags

A set of flag bits that describe the network. See kATalkInfoIsExtended.

Discussion

Use the AppleTalk information structure to obtain information about the current AppleTalk environment for the node on which your application is running.

Availability
Declared In
OpenTransportProviders.h

ATSvcRef

typedef struct OpaqueATSvcRef * ATSvcRef;
Availability
Declared In
OpenTransportProviders.h

bandinfo

struct bandinfo {
   unsigned char bi_pri;
   char pad1;
   SInt32 bi_flag;
};
typedef struct bandinfo bandinfo;
Fields
bi_pri
pad1
bi_flag
Availability
Declared In
OpenTransportProtocol.h

boolean_p

typedef Boolean boolean_p;
Availability
Declared In
OpenTransport.h

caddr_t

typedef char * caddr_t;
Availability
Declared In
types.h

CCMiscInfo

struct CCMiscInfo {
   UInt32 connectionStatus;
   UInt32 connectionTimeElapsed;
   UInt32 connectionTimeRemaining;
   UInt32 bytesTransmitted;
   UInt32 bytesReceived;
   UInt32 reserved;
};
typedef struct CCMiscInfo CCMiscInfo;
Fields
connectionStatus
connectionTimeElapsed
connectionTimeRemaining
bytesTransmitted
bytesReceived
reserved
Availability
Declared In
OpenTransportProviders.h

CFMLibraryInfo

struct CFMLibraryInfo {
   OTLink link;
   char * libName;
   StringPtr intlName;
   FSSpec * fileSpec;
   StringPtr pstring2;
   StringPtr pstring3;
};
typedef struct CFMLibraryInfo CFMLibraryInfo;
Fields
link
libName
intlName
fileSpec
pstring2
pstring3
Availability
Declared In
OpenTransportProtocol.h

char_p

typedef SInt8 char_p;
Availability
Declared In
OpenTransport.h

copyreq

struct copyreq {
   SInt32 cq_cmd;
   cred * cq_cr;
   UInt32 cq_id;
   caddr_t cq_addr;
   UInt32 cq_size;
   SInt32 cq_flag;
   mblk_t * cq_private;
   long cq_filler[4];
};
typedef struct copyreq copyreq;
Fields
cq_cmd
cq_cr
cq_id
cq_addr
cq_size
cq_flag
cq_private
cq_filler
Availability
Declared In
OpenTransportProtocol.h

copyresp

struct copyresp {
   SInt32 cp_cmd;
   cred * cp_cr;
   UInt32 cp_id;
   caddr_t cp_rval;
   UInt32 cp_pad1;
   SInt32 cp_pad2;
   mblk_t * cp_private;
   long cp_filler[4];
};
typedef struct copyresp copyresp;
Fields
cp_cmd
cp_cr
cp_id
cp_rval
cp_pad1
cp_pad2
cp_private
cp_filler
Availability
Declared In
OpenTransportProtocol.h

cred

struct cred {
   UInt16 cr_ref;
   UInt16 cr_ngroups;
   uid_t cr_uid;
   gid_t cr_gid;
   uid_t cr_ruid;
   gid_t cr_rgid;
   uid_t cr_suid;
   gid_t cr_sgid;
   gid_t cr_groups[1];
};
typedef struct cred cred;
typedef cred cred_t;
Fields
cr_ref
cr_ngroups
cr_uid
cr_gid
cr_ruid
cr_rgid
cr_suid
cr_sgid
cr_groups
Availability
Declared In
OpenTransportProtocol.h

cred_t

typedef cred cred_t;
Availability
Declared In
OpenTransportProtocol.h

datab

struct datab {
   datab_db_f db_f;
   unsigned char * db_base;
   unsigned char * db_lim;
   unsigned char db_ref;
   unsigned char db_type;
   unsigned char db_iswhat;
   unsigned char db_filler2;
   UInt32 db_size;
   unsigned char * db_msgaddr;
   long db_filler;
};
typedef struct datab datab;
typedef datab dblk_t;
Fields
db_f
db_base
db_lim
db_ref
db_type
db_iswhat
db_filler2
db_size
db_msgaddr
db_filler
Availability
Declared In
OpenTransportProtocol.h

datab_db_f

union datab_db_f {
   datab * freep;
   free_rtn * frtnp;
};
typedef union datab_db_f datab_db_f;
Fields
freep
frtnp
Availability
Declared In
OpenTransportProtocol.h

dblk_t

typedef datab dblk_t;
Availability
Declared In
OpenTransportProtocol.h

DDPAddress

struct DDPAddress {
   OTAddressType fAddressType;
   UInt16 fNetwork;
   UInt8 fNodeID;
   UInt8 fSocket;
   UInt8 fDDPType;
   UInt8 fPad;
};
typedef struct DDPAddress DDPAddress;
Fields
fAddressType
fNetwork
fNodeID
fSocket
fDDPType
fPad
Availability
Declared In
OpenTransportProviders.h

DDPNBPAddress

struct DDPNBPAddress {
   OTAddressType fAddressType;
   UInt16 fNetwork;
   UInt8 fNodeID;
   UInt8 fSocket;
   UInt8 fDDPType;
   UInt8 fPad;
   UInt8 fNBPNameBuffer[105];
};
typedef struct DDPNBPAddress DDPNBPAddress;
Fields
fAddressType
fNetwork
fNodeID
fSocket
fDDPType
fPad
fNBPNameBuffer
Availability
Declared In
OpenTransportProviders.h

dev_t

typedef UInt32 dev_t;
Availability
Declared In
types.h

dl_attach_req_t

struct dl_attach_req_t {
   UInt32 dl_primitive;
   UInt32 dl_ppa;
};
typedef struct dl_attach_req_t dl_attach_req_t;
Fields
dl_primitive
dl_ppa
Availability
Declared In
OpenTransportProtocol.h

dl_bind_ack_t

struct dl_bind_ack_t {
   UInt32 dl_primitive;
   UInt32 dl_sap;
   UInt32 dl_addr_length;
   UInt32 dl_addr_offset;
   UInt32 dl_max_conind;
   UInt32 dl_xidtest_flg;
};
typedef struct dl_bind_ack_t dl_bind_ack_t;
Fields
dl_primitive
dl_sap
dl_addr_length
dl_addr_offset
dl_max_conind
dl_xidtest_flg
Availability
Declared In
OpenTransportProtocol.h

dl_bind_req_t

struct dl_bind_req_t {
   UInt32 dl_primitive;
   UInt32 dl_sap;
   UInt32 dl_max_conind;
   UInt16 dl_service_mode;
   UInt16 dl_conn_mgmt;
   UInt32 dl_xidtest_flg;
};
typedef struct dl_bind_req_t dl_bind_req_t;
Fields
dl_primitive
dl_sap
dl_max_conind
dl_service_mode
dl_conn_mgmt
dl_xidtest_flg
Availability
Declared In
OpenTransportProtocol.h

dl_connect_con_t

struct dl_connect_con_t {
   UInt32 dl_primitive;
   UInt32 dl_resp_addr_length;
   UInt32 dl_resp_addr_offset;
   UInt32 dl_qos_length;
   UInt32 dl_qos_offset;
   UInt32 dl_growth;
};
typedef struct dl_connect_con_t dl_connect_con_t;
Fields
dl_primitive
dl_resp_addr_length
dl_resp_addr_offset
dl_qos_length
dl_qos_offset
dl_growth
Availability
Declared In
OpenTransportProtocol.h

dl_connect_ind_t

struct dl_connect_ind_t {
   UInt32 dl_primitive;
   UInt32 dl_correlation;
   UInt32 dl_called_addr_length;
   UInt32 dl_called_addr_offset;
   UInt32 dl_calling_addr_length;
   UInt32 dl_calling_addr_offset;
   UInt32 dl_qos_length;
   UInt32 dl_qos_offset;
   UInt32 dl_growth;
};
typedef struct dl_connect_ind_t dl_connect_ind_t;
Fields
dl_primitive
dl_correlation
dl_called_addr_length
dl_called_addr_offset
dl_calling_addr_length
dl_calling_addr_offset
dl_qos_length
dl_qos_offset
dl_growth
Availability
Declared In
OpenTransportProtocol.h

dl_connect_req_t

struct dl_connect_req_t {
   UInt32 dl_primitive;
   UInt32 dl_dest_addr_length;
   UInt32 dl_dest_addr_offset;
   UInt32 dl_qos_length;
   UInt32 dl_qos_offset;
   UInt32 dl_growth;
};
typedef struct dl_connect_req_t dl_connect_req_t;
Fields
dl_primitive
dl_dest_addr_length
dl_dest_addr_offset
dl_qos_length
dl_qos_offset
dl_growth
Availability
Declared In
OpenTransportProtocol.h

dl_connect_res_t

struct dl_connect_res_t {
   UInt32 dl_primitive;
   UInt32 dl_correlation;
   UInt32 dl_resp_token;
   UInt32 dl_qos_length;
   UInt32 dl_qos_offset;
   UInt32 dl_growth;
};
typedef struct dl_connect_res_t dl_connect_res_t;
Fields
dl_primitive
dl_correlation
dl_resp_token
dl_qos_length
dl_qos_offset
dl_growth
Availability
Declared In
OpenTransportProtocol.h

dl_data_ack_ind_t

struct dl_data_ack_ind_t {
   UInt32 dl_primitive;
   UInt32 dl_dest_addr_length;
   UInt32 dl_dest_addr_offset;
   UInt32 dl_src_addr_length;
   UInt32 dl_src_addr_offset;
   UInt32 dl_priority;
   UInt32 dl_service_class;
};
typedef struct dl_data_ack_ind_t dl_data_ack_ind_t;
Fields
dl_primitive
dl_dest_addr_length
dl_dest_addr_offset
dl_src_addr_length
dl_src_addr_offset
dl_priority
dl_service_class
Availability
Declared In
OpenTransportProtocol.h

dl_data_ack_req_t

struct dl_data_ack_req_t {
   UInt32 dl_primitive;
   UInt32 dl_correlation;
   UInt32 dl_dest_addr_length;
   UInt32 dl_dest_addr_offset;
   UInt32 dl_src_addr_length;
   UInt32 dl_src_addr_offset;
   UInt32 dl_priority;
   UInt32 dl_service_class;
};
typedef struct dl_data_ack_req_t dl_data_ack_req_t;
Fields
dl_primitive
dl_correlation
dl_dest_addr_length
dl_dest_addr_offset
dl_src_addr_length
dl_src_addr_offset
dl_priority
dl_service_class
Availability
Declared In
OpenTransportProtocol.h

dl_data_ack_status_ind_t

struct dl_data_ack_status_ind_t {
   UInt32 dl_primitive;
   UInt32 dl_correlation;
   UInt32 dl_status;
};
typedef struct dl_data_ack_status_ind_t dl_data_ack_status_ind_t;
Fields
dl_primitive
dl_correlation
dl_status
Availability
Declared In
OpenTransportProtocol.h

dl_detach_req_t

struct dl_detach_req_t {
   UInt32 dl_primitive;
};
typedef struct dl_detach_req_t dl_detach_req_t;
Fields
dl_primitive
Availability
Declared In
OpenTransportProtocol.h

dl_disabmulti_req_t

struct dl_disabmulti_req_t {
   UInt32 dl_primitive;
   UInt32 dl_addr_length;
   UInt32 dl_addr_offset;
};
typedef struct dl_disabmulti_req_t dl_disabmulti_req_t;
Fields
dl_primitive
dl_addr_length
dl_addr_offset
Availability
Declared In
OpenTransportProtocol.h

dl_disconnect_ind_t

struct dl_disconnect_ind_t {
   UInt32 dl_primitive;
   UInt32 dl_originator;
   UInt32 dl_reason;
   UInt32 dl_correlation;
};
typedef struct dl_disconnect_ind_t dl_disconnect_ind_t;
Fields
dl_primitive
dl_originator
dl_reason
dl_correlation
Availability
Declared In
OpenTransportProtocol.h

dl_disconnect_req_t

struct dl_disconnect_req_t {
   UInt32 dl_primitive;
   UInt32 dl_reason;
   UInt32 dl_correlation;
};
typedef struct dl_disconnect_req_t dl_disconnect_req_t;
Fields
dl_primitive
dl_reason
dl_correlation
Availability
Declared In
OpenTransportProtocol.h

dl_enabmulti_req_t

struct dl_enabmulti_req_t {
   UInt32 dl_primitive;
   UInt32 dl_addr_length;
   UInt32 dl_addr_offset;
};
typedef struct dl_enabmulti_req_t dl_enabmulti_req_t;
Fields
dl_primitive
dl_addr_length
dl_addr_offset
Availability
Declared In
OpenTransportProtocol.h

dl_error_ack_t

struct dl_error_ack_t {
   UInt32 dl_primitive;
   UInt32 dl_error_primitive;
   UInt32 dl_errno;
   UInt32 dl_unix_errno;
};
typedef struct dl_error_ack_t dl_error_ack_t;
Fields
dl_primitive
dl_error_primitive
dl_errno
dl_unix_errno
Availability
Declared In
OpenTransportProtocol.h

dl_get_statistics_ack_t

struct dl_get_statistics_ack_t {
   UInt32 dl_primitive;
   UInt32 dl_stat_length;
   UInt32 dl_stat_offset;
};
typedef struct dl_get_statistics_ack_t dl_get_statistics_ack_t;
Fields
dl_primitive
dl_stat_length
dl_stat_offset
Availability
Declared In
OpenTransportProtocol.h

dl_get_statistics_req_t

struct dl_get_statistics_req_t {
   UInt32 dl_primitive;
};
typedef struct dl_get_statistics_req_t dl_get_statistics_req_t;
Fields
dl_primitive
Availability
Declared In
OpenTransportProtocol.h

dl_info_ack_t

struct dl_info_ack_t {
   UInt32 dl_primitive;
   UInt32 dl_max_sdu;
   UInt32 dl_min_sdu;
   UInt32 dl_addr_length;
   UInt32 dl_mac_type;
   UInt32 dl_reserved;
   UInt32 dl_current_state;
   SInt32 dl_sap_length;
   UInt32 dl_service_mode;
   UInt32 dl_qos_length;
   UInt32 dl_qos_offset;
   UInt32 dl_qos_range_length;
   UInt32 dl_qos_range_offset;
   UInt32 dl_provider_style;
   UInt32 dl_addr_offset;
   UInt32 dl_version;
   UInt32 dl_brdcst_addr_length;
   UInt32 dl_brdcst_addr_offset;
   UInt32 dl_growth;
};
typedef struct dl_info_ack_t dl_info_ack_t;
Fields
dl_primitive
dl_max_sdu
dl_min_sdu
dl_addr_length
dl_mac_type
dl_reserved
dl_current_state
dl_sap_length
dl_service_mode
dl_qos_length
dl_qos_offset
dl_qos_range_length
dl_qos_range_offset
dl_provider_style
dl_addr_offset
dl_version
dl_brdcst_addr_length
dl_brdcst_addr_offset
dl_growth
Availability
Declared In
OpenTransportProtocol.h

dl_info_req_t

struct dl_info_req_t {
   UInt32 dl_primitive;
};
typedef struct dl_info_req_t dl_info_req_t;
Fields
dl_primitive
Availability
Declared In
OpenTransportProtocol.h

dl_ok_ack_t

struct dl_ok_ack_t {
   UInt32 dl_primitive;
   UInt32 dl_correct_primitive;
};
typedef struct dl_ok_ack_t dl_ok_ack_t;
Fields
dl_primitive
dl_correct_primitive
Availability
Declared In
OpenTransportProtocol.h

dl_phys_addr_ack_t

struct dl_phys_addr_ack_t {
   UInt32 dl_primitive;
   UInt32 dl_addr_length;
   UInt32 dl_addr_offset;
};
typedef struct dl_phys_addr_ack_t dl_phys_addr_ack_t;
Fields
dl_primitive
dl_addr_length
dl_addr_offset
Availability
Declared In
OpenTransportProtocol.h

dl_phys_addr_req_t

struct dl_phys_addr_req_t {
   UInt32 dl_primitive;
   UInt32 dl_addr_type;
};
typedef struct dl_phys_addr_req_t dl_phys_addr_req_t;
Fields
dl_primitive
dl_addr_type
Availability
Declared In
OpenTransportProtocol.h

DL_primitives

union DL_primitives {
   UInt32 dl_primitive;
   dl_info_req_t info_req;
   dl_info_ack_t info_ack;
   dl_attach_req_t attach_req;
   dl_detach_req_t detach_req;
   dl_bind_req_t bind_req;
   dl_bind_ack_t bind_ack;
   dl_unbind_req_t unbind_req;
   dl_subs_bind_req_t subs_bind_req;
   dl_subs_bind_ack_t subs_bind_ack;
   dl_subs_unbind_req_t subs_unbind_req;
   dl_ok_ack_t ok_ack;
   dl_error_ack_t error_ack;
   dl_connect_req_t connect_req;
   dl_connect_ind_t connect_ind;
   dl_connect_res_t connect_res;
   dl_connect_con_t connect_con;
   dl_token_req_t token_req;
   dl_token_ack_t token_ack;
   dl_disconnect_req_t disconnect_req;
   dl_disconnect_ind_t disconnect_ind;
   dl_reset_req_t reset_req;
   dl_reset_ind_t reset_ind;
   dl_reset_res_t reset_res;
   dl_reset_con_t reset_con;
   dl_unitdata_req_t unitdata_req;
   dl_unitdata_ind_t unitdata_ind;
   dl_uderror_ind_t uderror_ind;
   dl_udqos_req_t udqos_req;
   dl_enabmulti_req_t enabmulti_req;
   dl_disabmulti_req_t disabmulti_req;
   dl_promiscon_req_t promiscon_req;
   dl_promiscoff_req_t promiscoff_req;
   dl_phys_addr_req_t physaddr_req;
   dl_phys_addr_ack_t physaddr_ack;
   dl_set_phys_addr_req_t set_physaddr_req;
   dl_get_statistics_req_t get_statistics_req;
   dl_get_statistics_ack_t get_statistics_ack;
   dl_test_req_t test_req;
   dl_test_ind_t test_ind;
   dl_test_res_t test_res;
   dl_test_con_t test_con;
   dl_xid_req_t xid_req;
   dl_xid_ind_t xid_ind;
   dl_xid_res_t xid_res;
   dl_xid_con_t xid_con;
   dl_data_ack_req_t data_ack_req;
   dl_data_ack_ind_t data_ack_ind;
   dl_data_ack_status_ind_t data_ack_status_ind;
   dl_reply_req_t reply_req;
   dl_reply_ind_t reply_ind;
   dl_reply_status_ind_t reply_status_ind;
   dl_reply_update_req_t reply_update_req;
   dl_reply_update_status_ind_t reply_update_status_ind;
};
typedef union DL_primitives DL_primitives;
Fields
dl_primitive
info_req
info_ack
attach_req
detach_req
bind_req
bind_ack
unbind_req
subs_bind_req
subs_bind_ack
subs_unbind_req
ok_ack
error_ack
connect_req
connect_ind
connect_res
connect_con
token_req
token_ack
disconnect_req
disconnect_ind
reset_req
reset_ind
reset_res
reset_con
unitdata_req
unitdata_ind
uderror_ind
udqos_req
enabmulti_req
disabmulti_req
promiscon_req
promiscoff_req
physaddr_req
physaddr_ack
set_physaddr_req
get_statistics_req
get_statistics_ack
test_req
test_ind
test_res
test_con
xid_req
xid_ind
xid_res
xid_con
Availability
Declared In
OpenTransportProtocol.h

dl_priority_t

struct dl_priority_t {
   SInt32 dl_min;
   SInt32 dl_max;
};
typedef struct dl_priority_t dl_priority_t;
Fields
dl_min
dl_max
Availability
Declared In
OpenTransportProtocol.h

dl_promiscoff_req_t

struct dl_promiscoff_req_t {
   UInt32 dl_primitive;
   UInt32 dl_level;
};
typedef struct dl_promiscoff_req_t dl_promiscoff_req_t;
Fields
dl_primitive
dl_level
Availability
Declared In
OpenTransportProtocol.h

dl_promiscon_req_t

struct dl_promiscon_req_t {
   UInt32 dl_primitive;
   UInt32 dl_level;
};
typedef struct dl_promiscon_req_t dl_promiscon_req_t;
Fields
dl_primitive
dl_level
Availability
Declared In
OpenTransportProtocol.h

dl_protect_t

struct dl_protect_t {
   SInt32 dl_min;
   SInt32 dl_max;
};
typedef struct dl_protect_t dl_protect_t;
Fields
dl_min
dl_max
Availability
Declared In
OpenTransportProtocol.h

dl_qos_cl_range1_t

struct dl_qos_cl_range1_t {
   UInt32 dl_qos_type;
   dl_transdelay_t dl_trans_delay;
   dl_priority_t dl_priority;
   dl_protect_t dl_protection;
   SInt32 dl_residual_error;
};
typedef struct dl_qos_cl_range1_t dl_qos_cl_range1_t;
Fields
dl_qos_type
dl_trans_delay
dl_priority
dl_protection
dl_residual_error
Availability
Declared In
OpenTransportProtocol.h

dl_qos_cl_sel1_t

struct dl_qos_cl_sel1_t {
   UInt32 dl_qos_type;
   SInt32 dl_trans_delay;
   SInt32 dl_priority;
   SInt32 dl_protection;
   SInt32 dl_residual_error;
};
typedef struct dl_qos_cl_sel1_t dl_qos_cl_sel1_t;
Fields
dl_qos_type
dl_trans_delay
dl_priority
dl_protection
dl_residual_error
Availability
Declared In
OpenTransportProtocol.h

dl_qos_co_range1_t

struct dl_qos_co_range1_t {
   UInt32 dl_qos_type;
   dl_through_t dl_rcv_throughput;
   dl_transdelay_t dl_rcv_trans_delay;
   dl_through_t dl_xmt_throughput;
   dl_transdelay_t dl_xmt_trans_delay;
   dl_priority_t dl_priority;
   dl_protect_t dl_protection;
   SInt32 dl_residual_error;
   dl_resilience_t dl_resilience;
};
typedef struct dl_qos_co_range1_t dl_qos_co_range1_t;
Fields
dl_qos_type
dl_rcv_throughput
dl_rcv_trans_delay
dl_xmt_throughput
dl_xmt_trans_delay
dl_priority
dl_protection
dl_residual_error
dl_resilience
Availability
Declared In
OpenTransportProtocol.h

dl_qos_co_sel1_t

struct dl_qos_co_sel1_t {
   UInt32 dl_qos_type;
   SInt32 dl_rcv_throughput;
   SInt32 dl_rcv_trans_delay;
   SInt32 dl_xmt_throughput;
   SInt32 dl_xmt_trans_delay;
   SInt32 dl_priority;
   SInt32 dl_protection;
   SInt32 dl_residual_error;
   dl_resilience_t dl_resilience;
};
typedef struct dl_qos_co_sel1_t dl_qos_co_sel1_t;
Fields
dl_qos_type
dl_rcv_throughput
dl_rcv_trans_delay
dl_xmt_throughput
dl_xmt_trans_delay
dl_priority
dl_protection
dl_residual_error
dl_resilience
Availability
Declared In
OpenTransportProtocol.h

dl_reply_ind_t

struct dl_reply_ind_t {
   UInt32 dl_primitive;
   UInt32 dl_dest_addr_length;
   UInt32 dl_dest_addr_offset;
   UInt32 dl_src_addr_length;
   UInt32 dl_src_addr_offset;
   UInt32 dl_priority;
   UInt32 dl_service_class;
};
typedef struct dl_reply_ind_t dl_reply_ind_t;
Fields
dl_primitive
dl_dest_addr_length
dl_dest_addr_offset
dl_src_addr_length
dl_src_addr_offset
dl_priority
dl_service_class
Availability
Declared In
OpenTransportProtocol.h

dl_reply_req_t

struct dl_reply_req_t {
   UInt32 dl_primitive;
   UInt32 dl_correlation;
   UInt32 dl_dest_addr_length;
   UInt32 dl_dest_addr_offset;
   UInt32 dl_src_addr_length;
   UInt32 dl_src_addr_offset;
   UInt32 dl_priority;
   UInt32 dl_service_class;
};
typedef struct dl_reply_req_t dl_reply_req_t;
Fields
dl_primitive
dl_correlation
dl_dest_addr_length
dl_dest_addr_offset
dl_src_addr_length
dl_src_addr_offset
dl_priority
dl_service_class
Availability
Declared In
OpenTransportProtocol.h

dl_reply_status_ind_t

struct dl_reply_status_ind_t {
   UInt32 dl_primitive;
   UInt32 dl_correlation;
   UInt32 dl_status;
};
typedef struct dl_reply_status_ind_t dl_reply_status_ind_t;
Fields
dl_primitive
dl_correlation
dl_status
Availability
Declared In
OpenTransportProtocol.h

dl_reply_update_req_t

struct dl_reply_update_req_t {
   UInt32 dl_primitive;
   UInt32 dl_correlation;
   UInt32 dl_src_addr_length;
   UInt32 dl_src_addr_offset;
};
typedef struct dl_reply_update_req_t dl_reply_update_req_t;
Fields
dl_primitive
dl_correlation
dl_src_addr_length
dl_src_addr_offset
Availability
Declared In
OpenTransportProtocol.h

dl_reply_update_status_ind_t

struct dl_reply_update_status_ind_t {
   UInt32 dl_primitive;
   UInt32 dl_correlation;
   UInt32 dl_status;
};
typedef struct dl_reply_update_status_ind_t dl_reply_update_status_ind_t;
Fields
dl_primitive
dl_correlation
dl_status
Availability
Declared In
OpenTransportProtocol.h

dl_reset_con_t

struct dl_reset_con_t {
   UInt32 dl_primitive;
};
typedef struct dl_reset_con_t dl_reset_con_t;
Fields
dl_primitive
Availability
Declared In
OpenTransportProtocol.h

dl_reset_ind_t

struct dl_reset_ind_t {
   UInt32 dl_primitive;
   UInt32 dl_originator;
   UInt32 dl_reason;
};
typedef struct dl_reset_ind_t dl_reset_ind_t;
Fields
dl_primitive
dl_originator
dl_reason
Availability
Declared In
OpenTransportProtocol.h

dl_reset_req_t

struct dl_reset_req_t {
   UInt32 dl_primitive;
};
typedef struct dl_reset_req_t dl_reset_req_t;
Fields
dl_primitive
Availability
Declared In
OpenTransportProtocol.h

dl_reset_res_t

struct dl_reset_res_t {
   UInt32 dl_primitive;
};
typedef struct dl_reset_res_t dl_reset_res_t;
Fields
dl_primitive
Availability
Declared In
OpenTransportProtocol.h

dl_resilience_t

struct dl_resilience_t {
   SInt32 dl_disc_prob;
   SInt32 dl_reset_prob;
};
typedef struct dl_resilience_t dl_resilience_t;
Fields
dl_disc_prob
dl_reset_prob
Availability
Declared In
OpenTransportProtocol.h

dl_set_phys_addr_req_t

struct dl_set_phys_addr_req_t {
   UInt32 dl_primitive;
   UInt32 dl_addr_length;
   UInt32 dl_addr_offset;
};
typedef struct dl_set_phys_addr_req_t dl_set_phys_addr_req_t;
Fields
dl_primitive
dl_addr_length
dl_addr_offset
Availability
Declared In
OpenTransportProtocol.h

dl_subs_bind_ack_t

struct dl_subs_bind_ack_t {
   UInt32 dl_primitive;
   UInt32 dl_subs_sap_offset;
   UInt32 dl_subs_sap_length;
};
typedef struct dl_subs_bind_ack_t dl_subs_bind_ack_t;
Fields
dl_primitive
dl_subs_sap_offset
dl_subs_sap_length
Availability
Declared In
OpenTransportProtocol.h

dl_subs_bind_req_t

struct dl_subs_bind_req_t {
   UInt32 dl_primitive;
   UInt32 dl_subs_sap_offset;
   UInt32 dl_subs_sap_length;
   UInt32 dl_subs_bind_class;
};
typedef struct dl_subs_bind_req_t dl_subs_bind_req_t;
Fields
dl_primitive
dl_subs_sap_offset
dl_subs_sap_length
dl_subs_bind_class
Availability
Declared In
OpenTransportProtocol.h

dl_subs_unbind_req_t

struct dl_subs_unbind_req_t {
   UInt32 dl_primitive;
   UInt32 dl_subs_sap_offset;
   UInt32 dl_subs_sap_length;
};
typedef struct dl_subs_unbind_req_t dl_subs_unbind_req_t;
Fields
dl_primitive
dl_subs_sap_offset
dl_subs_sap_length
Availability
Declared In
OpenTransportProtocol.h

dl_test_con_t

struct dl_test_con_t {
   UInt32 dl_primitive;
   UInt32 dl_flag;
   UInt32 dl_dest_addr_length;
   UInt32 dl_dest_addr_offset;
   UInt32 dl_src_addr_length;
   UInt32 dl_src_addr_offset;
};
typedef struct dl_test_con_t dl_test_con_t;
Fields
dl_primitive
dl_flag
dl_dest_addr_length
dl_dest_addr_offset
dl_src_addr_length
dl_src_addr_offset
Availability
Declared In
OpenTransportProtocol.h

dl_test_ind_t

struct dl_test_ind_t {
   UInt32 dl_primitive;
   UInt32 dl_flag;
   UInt32 dl_dest_addr_length;
   UInt32 dl_dest_addr_offset;
   UInt32 dl_src_addr_length;
   UInt32 dl_src_addr_offset;
};
typedef struct dl_test_ind_t dl_test_ind_t;
Fields
dl_primitive
dl_flag
dl_dest_addr_length
dl_dest_addr_offset
dl_src_addr_length
dl_src_addr_offset
Availability
Declared In
OpenTransportProtocol.h

dl_test_req_t

struct dl_test_req_t {
   UInt32 dl_primitive;
   UInt32 dl_flag;
   UInt32 dl_dest_addr_length;
   UInt32 dl_dest_addr_offset;
};
typedef struct dl_test_req_t dl_test_req_t;
Fields
dl_primitive
dl_flag
dl_dest_addr_length
dl_dest_addr_offset
Availability
Declared In
OpenTransportProtocol.h

dl_test_res_t

struct dl_test_res_t {
   UInt32 dl_primitive;
   UInt32 dl_flag;
   UInt32 dl_dest_addr_length;
   UInt32 dl_dest_addr_offset;
};
typedef struct dl_test_res_t dl_test_res_t;
Fields
dl_primitive
dl_flag
dl_dest_addr_length
dl_dest_addr_offset
Availability
Declared In
OpenTransportProtocol.h

dl_through_t

struct dl_through_t {
   SInt32 dl_target_value;
   SInt32 dl_accept_value;
};
typedef struct dl_through_t dl_through_t;
Fields
dl_target_value
dl_accept_value
Availability
Declared In
OpenTransportProtocol.h

dl_token_ack_t

struct dl_token_ack_t {
   UInt32 dl_primitive;
   UInt32 dl_token;
};
typedef struct dl_token_ack_t dl_token_ack_t;
Fields
dl_primitive
dl_token
Availability
Declared In
OpenTransportProtocol.h

dl_token_req_t

struct dl_token_req_t {
   UInt32 dl_primitive;
};
typedef struct dl_token_req_t dl_token_req_t;
Fields
dl_primitive
Availability
Declared In
OpenTransportProtocol.h

dl_transdelay_t

struct dl_transdelay_t {
   SInt32 dl_target_value;
   SInt32 dl_accept_value;
};
typedef struct dl_transdelay_t dl_transdelay_t;
Fields
dl_target_value
dl_accept_value
Availability
Declared In
OpenTransportProtocol.h

dl_uderror_ind_t

struct dl_uderror_ind_t {
   UInt32 dl_primitive;
   UInt32 dl_dest_addr_length;
   UInt32 dl_dest_addr_offset;
   UInt32 dl_unix_errno;
   UInt32 dl_errno;
};
typedef struct dl_uderror_ind_t dl_uderror_ind_t;
Fields
dl_primitive
dl_dest_addr_length
dl_dest_addr_offset
dl_unix_errno
dl_errno
Availability
Declared In
OpenTransportProtocol.h

dl_udqos_req_t

struct dl_udqos_req_t {
   UInt32 dl_primitive;
   UInt32 dl_qos_length;
   UInt32 dl_qos_offset;
};
typedef struct dl_udqos_req_t dl_udqos_req_t;
Fields
dl_primitive
dl_qos_length
dl_qos_offset
Availability
Declared In
OpenTransportProtocol.h

dl_unbind_req_t

struct dl_unbind_req_t {
   UInt32 dl_primitive;
};
typedef struct dl_unbind_req_t dl_unbind_req_t;
Fields
dl_primitive
Availability
Declared In
OpenTransportProtocol.h

dl_unitdata_ind_t

struct dl_unitdata_ind_t {
   UInt32 dl_primitive;
   UInt32 dl_dest_addr_length;
   UInt32 dl_dest_addr_offset;
   UInt32 dl_src_addr_length;
   UInt32 dl_src_addr_offset;
   UInt32 dl_group_address;
};
typedef struct dl_unitdata_ind_t dl_unitdata_ind_t;
Fields
dl_primitive
dl_dest_addr_length
dl_dest_addr_offset
dl_src_addr_length
dl_src_addr_offset
dl_group_address
Availability
Declared In
OpenTransportProtocol.h

dl_unitdata_req_t

struct dl_unitdata_req_t {
   UInt32 dl_primitive;
   UInt32 dl_dest_addr_length;
   UInt32 dl_dest_addr_offset;
   dl_priority_t dl_priority;
};
typedef struct dl_unitdata_req_t dl_unitdata_req_t;
Fields
dl_primitive
dl_dest_addr_length
dl_dest_addr_offset
dl_priority
Availability
Declared In
OpenTransportProtocol.h

dl_xid_con_t

struct dl_xid_con_t {
   UInt32 dl_primitive;
   UInt32 dl_flag;
   UInt32 dl_dest_addr_length;
   UInt32 dl_dest_addr_offset;
   UInt32 dl_src_addr_length;
   UInt32 dl_src_addr_offset;
};
typedef struct dl_xid_con_t dl_xid_con_t;
Fields
dl_primitive
dl_flag
dl_dest_addr_length
dl_dest_addr_offset
dl_src_addr_length
dl_src_addr_offset
Availability
Declared In
OpenTransportProtocol.h

dl_xid_ind_t

struct dl_xid_ind_t {
   UInt32 dl_primitive;
   UInt32 dl_flag;
   UInt32 dl_dest_addr_length;
   UInt32 dl_dest_addr_offset;
   UInt32 dl_src_addr_length;
   UInt32 dl_src_addr_offset;
};
typedef struct dl_xid_ind_t dl_xid_ind_t;
Fields
dl_primitive
dl_flag
dl_dest_addr_length
dl_dest_addr_offset
dl_src_addr_length
dl_src_addr_offset
Availability
Declared In
OpenTransportProtocol.h

dl_xid_req_t

struct dl_xid_req_t {
   UInt32 dl_primitive;
   UInt32 dl_flag;
   UInt32 dl_dest_addr_length;
   UInt32 dl_dest_addr_offset;
};
typedef struct dl_xid_req_t dl_xid_req_t;
Fields
dl_primitive
dl_flag
dl_dest_addr_length
dl_dest_addr_offset
Availability
Declared In
OpenTransportProtocol.h

dl_xid_res_t

struct dl_xid_res_t {
   UInt32 dl_primitive;
   UInt32 dl_flag;
   UInt32 dl_dest_addr_length;
   UInt32 dl_dest_addr_offset;
};
typedef struct dl_xid_res_t dl_xid_res_t;
Fields
dl_primitive
dl_flag
dl_dest_addr_length
dl_dest_addr_offset
Availability
Declared In
OpenTransportProtocol.h

DNS Address Structure

Holds host names, partially or fully-qualified domain names, or dotted-decimal format Internet addresses for use with a variety of Open Transport functions.

struct DNSAddress {
   OTAddressType fAddressType;
   InetDomainName fName;
};
typedef struct DNSAddress DNSAddress;
Fields
fAddressType

The address type. For a DNSAddress structure, this should be AF_DNS.

fName

The name to be resolved by the DNR.

Discussion

You can use the DNS (domain name system) address structure with the OTConnect function (TCP), with the OTSndUData function (UDP), or with the OTResolveAddress function (either TCP or UDP). If you do so, TCP/IP will resolve the name for you automatically. You can use the OTInitDNSAddress function to fill in a DNS address structure. The DNS address structure is defined by the DNSAddress data type.

The address you specify can be just the host name (“otteam”), a partially qualified domain name (“otteam.ssw”), a fully qualified domain name (“otteam.ssw.apple.com.”), or an internet address in dotted-decimal format (“17.202.99.99”), and can optionally include a port number (“otteam.ssw.apple.com:25” or “17.202.99.99:25”).

Because the port number is not actually part of the domain name, it is possible to have a domain name–port number combination that exceeds 255 bytes. If you wish to specify such a string, you must provide a structure based on the DNS address structure that has sufficient space to contain the full string. In any case, the domain name itself cannot exceed 255 bytes.

Availability
Declared In
OpenTransportProviders.h

DNS Query Information Structure

Returns answers to DNS queries.

struct DNSQueryInfo {
   UInt16 qType;
   UInt16 qClass;
   UInt32 ttl;
   InetDomainName name;
   UInt16 responseType;
   UInt16 resourceLen;
   char resourceData[4];
};
typedef struct DNSQueryInfo DNSQueryInfo;
Fields
qType

The numerical value of the DNS resource record type, such as MX and PTR, for which you wish to query.

qClass

The numerical value of the DNS record class, such as Inet and Hesio, for which you wish to query.

ttl

An integer indicating the DNS resource record’s time to live (in seconds).

name

The fully qualified domain name or address for which you made the query.

responseType

The type of response.

resourceLen

The actual length of the resource data returned.

resourceData

The resource data that is returned. This is at least 4 bytes long, and is usually longer.

Discussion

The DNS query information structure is used by the TCP/IP service provider to return answers to DNS queries made using the OTInetQuery function. The DNS query information structure is defined by the DNSQueryInfo data type. For additional information about the constant values for the DNSQueryInfo fields, see the DNS Requests for Comments (RFCs), available over the World Wide Web.

See the Internet Standard for a definitive list of values for the qType, qClass, and respnoseType fields, and for a definition of the format of the resource data.

Availability
Declared In
OpenTransportProviders.h

EndpointRef

typedef struct OpaqueEndpointRef * EndpointRef;
Availability
Declared In
OpenTransport.h

EnetPacketHeader

struct EnetPacketHeader {
   UInt8 fDestAddr[6];
   UInt8 fSourceAddr[6];
   UInt16 fProto;
};
typedef struct EnetPacketHeader EnetPacketHeader;
Fields
fDestAddr
fSourceAddr
fProto
Availability
Declared In
OpenTransportProviders.h

free_rtn

struct free_rtn {
   FreeFuncType free_func;
   char * free_arg;
};
typedef struct free_rtn free_rtn;
typedef free_rtn frtn_t;
Fields
free_func
free_arg
Availability
Declared In
OpenTransportProtocol.h

frtn_t

typedef free_rtn frtn_t;
Availability
Declared In
OpenTransportProtocol.h

gid_t

typedef UInt32 gid_t;
Availability
Declared In
types.h

Internet Address Structure

Used for providing a TCP or UDP address to the OTConnect, OTSndURequest, or OTBind functions.

struct InetAddress {
   OTAddressType fAddressType;
   InetPort fPort;
   InetHost fHost;
   UInt8 fUnused[8];
};
typedef struct InetAddress InetAddress;
Fields
fAddressType

The address type. The field should be AF_INET, which identifies the structure as an InetAddress.

fPort

The port number.

fHost

The 32-bit IP address of the host.

fUnused

Reserved.

Availability
Declared In
OpenTransportProviders.h

InetDHCPOption

struct InetDHCPOption {
   UInt8 fOptionTag;
   UInt8 fOptionLen;
   UInt8 fOptionValue;
};
typedef struct InetDHCPOption InetDHCPOption;
Fields
fOptionTag
fOptionLen
fOptionValue
Availability
Declared In
OpenTransportProviders.h

InetDomainName

typedef  InetDomainName[256];
Availability
Declared In
OpenTransportProviders.h

InetHost

typedef UInt32 InetHost;
Availability
Declared In
OpenTransportProviders.h

Internet Host Information Sructure

Holds a set of IP addresses associated with an Internet host for use by the OTInetStringToAddress function.

struct InetHostInfo {
   InetDomainName name;
   InetHost addrs[10];
};
typedef struct InetHostInfo InetHostInfo;
Fields
name

The canonical name of the host. The canonical name is a fully qualified domain nam, never an alias.

addrs

Up to ten IP addresses associated with this host name. Only multihomed hosts have more than one IP address.

Availability
Declared In
OpenTransportProviders.h

Internet Interface Information Structure

Holds information about an Internet interface for use by the OTInetGetInterfaceInfo function.

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;
Fields
fAddress

The IP address of the interface.

fNetmask

The subnet mask of the local IP network.

fBroadcastAddr

The broadcast address for the interface.

fDefaultGatewayAddr

The IP address of the default router. The default is a router that can forward any packet destined outside the locally connected subnet.

fDNSAddr

The address of a domain name server. This value can be returned by a server or typed in by the user during configuration of the TCP/IP interface.

fVersion

The version of the OTInetGetInterfaceInfo function; currently equal to kInetInterfaceInfoVersion.

fHWAddrLen

The length (in bytes) of the hardware address. This points into the fReserved field of this structure. It can be nil if the interface has no hardware address or if it won’t fit.

fHWAddr

A pointer to the hardware address.

fIfMTU

The maximum transmission unit size in bytes permitted for this interface’s hardware.

fReservedPtrs

Reserved.

fDomainName

The default domain name of the host as configured in the TCP/IP control panel. This name doesn’t include the host name.

fIPSecondaryCount

The number of IP secondary address available.

fReserved

Reserved.

Availability
Declared In
OpenTransportProviders.h

Internet Mail Exchange Structure

Holds host names and mail preference values for use with the OTInetMailExchange function.

struct InetMailExchange {
   UInt16 preference;
   InetDomainName exchange;
};
typedef struct InetMailExchange InetMailExchange;
Fields
preference

The mail exchange preference value. The mail exchanger with the lowest preference number is the first one to which mail should be sent.

exchange

The fully qualified domain name of a host that can accept mail for your target host.

Availability
Declared In
OpenTransportProviders.h

InetPort

typedef UInt16 InetPort;
Availability
Declared In
OpenTransportProviders.h

InetSvcRef

typedef struct OpaqueInetSvcRef * InetSvcRef;
Availability
Declared In
OpenTransportProviders.h

InetSysInfo

Holds information about an Internet host for use by the OTInetSysInfo function.

struct InetSysInfo {
   char cpuType[32];
   char osType[32];
};
typedef struct InetSysInfo InetSysInfo;
Fields
cpuType

The CPU type of the specified host. This is an ASCII string maintained by the domain name server.

osType

The operating system running on the specified host. This is an ASCII string maintained by the domain name server.

Availability
Declared In
OpenTransportProviders.h

install_info


Fields

int_t

typedef  int_t;
Availability
Declared In
OpenTransport.h

iocblk

struct iocblk {
   SInt32 ioc_cmd;
   cred * ioc_cr;
   UInt32 ioc_id;
   UInt32 ioc_count;
   SInt32 ioc_error;
   SInt32 ioc_rval;
   long ioc_filler[4];
};
typedef struct iocblk iocblk;
Fields
ioc_cmd
ioc_cr
ioc_id
ioc_count
ioc_error
ioc_rval
ioc_filler
Availability
Declared In
OpenTransportProtocol.h

LCPEcho

struct LCPEcho {
   UInt32 retryCount;
   UInt32 retryPeriod;
};
typedef struct LCPEcho LCPEcho;
Fields
retryCount
retryPeriod
Availability
Declared In
OpenTransportProviders.h

linkblk

struct linkblk {
   queue_t * l_qtop;
   queue_t * l_qbot;
   SInt32 l_index;
   long l_pad[5];
};
typedef struct linkblk linkblk;
Fields
l_qtop
l_qbot
l_index
l_pad
Availability
Declared In
OpenTransportProtocol.h

log_ctl

struct log_ctl {
   short mid;
   short sid;
   char level;
   char pad1;
   short flags;
   long ltime;
   long ttime;
   SInt32 seq_no;
};
typedef struct log_ctl log_ctl;
Fields
mid
sid
level
pad1
flags
ltime
ttime
seq_no
Availability
Declared In
OpenTransportProtocol.h

major_t

typedef UInt16 major_t;

MapperRef

typedef struct OpaqueMapperRef * MapperRef;
Availability
Declared In
OpenTransport.h

mblk_t

typedef msgb mblk_t;
Availability
Declared In
OpenTransportProtocol.h

minor_t

typedef UInt16 minor_t;

module_info

struct module_info {
   unsigned short mi_idnum;
   char * mi_idname;
   long mi_minpsz;
   long mi_maxpsz;
   unsigned long mi_hiwat;
   unsigned long mi_lowat;
};
typedef struct module_info module_info;
typedef module_info * module_infoPtr;
Fields
mi_idnum
mi_idname
mi_minpsz
mi_maxpsz
mi_hiwat
mi_lowat
Availability
Declared In
OpenTransportProtocol.h

module_stat

struct module_stat {
   long ms_pcnt;
   long ms_scnt;
   long ms_ocnt;
   long ms_ccnt;
   long ms_acnt;
   char * ms_xptr;
   short ms_xsize;
};
typedef struct module_stat module_stat;
Fields
ms_pcnt
ms_scnt
ms_ocnt
ms_ccnt
ms_acnt
ms_xptr
ms_xsize
Availability
Declared In
OpenTransportProtocol.h

MPS_INTR_STATE

typedef UInt8 MPS_INTR_STATE;

msgb

struct msgb {
   struct msgb * b_next;
      struct msgb * b_prev;
         struct msgb * b_cont;
            unsigned char * b_rptr;
            unsigned char * b_wptr;
            datab * b_datap;
            unsigned char b_band;
            unsigned char b_pad1;
            unsigned short b_flag;
         };
         typedef struct msgb msgb;
         typedef msgb mblk_t;
Fields
b_next
b_prev
b_cont
b_rptr
b_wptr
b_datap
b_band
b_pad1
b_flag
Availability
Declared In
OpenTransportProtocol.h

NBPAddress

struct NBPAddress {
   OTAddressType fAddressType;
   UInt8 fNBPNameBuffer[105];
};
typedef struct NBPAddress NBPAddress;
Fields
fAddressType
fNBPNameBuffer
Availability
Declared In
OpenTransportProviders.h

NBPEntity

struct NBPEntity {
   UInt8 fEntity[99];
};
typedef struct NBPEntity NBPEntity;
Fields
fEntity
Availability
Declared In
OpenTransportProviders.h

netbuf

struct netbuf {
   maxlen;
   len;
   char *buf;
};
Fields

ot_bind


Fields

ot_optmgmt


Fields

OTAddress

Defines the common structure for all Open Transport addresses.

struct OTAddress {
   OTAddressType fAddressType;
   UInt8 fAddress[1];
};
typedef struct OTAddress OTAddress;
Fields
fAddressType
fAddress
Discussion

The OTAddress type itself is abstract. You would not declare a structure of this type because it does not contain any address information. However, address formats defined by Open Transport protocols all use the fAddressType field to describe the format of the fields to follow, which do contain address information.

Availability
Declared In
OpenTransport.h

OTAddressType

typedef UInt16 OTAddressType;
Availability
Declared In
OpenTransport.h

OTAutopushInfo

struct OTAutopushInfo {
   UInt32 sap_cmd;
   char sap_device_name[32];
   SInt32 sap_minor;
   SInt32 sap_lastminor;
   SInt32 sap_npush;
   char sap_list[8][32];
};
typedef struct OTAutopushInfo OTAutopushInfo;
Fields
sap_cmd
sap_device_name
sap_minor
sap_lastminor
sap_npush
sap_list
Availability
Declared In
OpenTransportProtocol.h

OTBand

typedef UInt32 OTBand;
Availability
Declared In
OpenTransport.h

OTBooleanParam

typedef Boolean OTBooleanParam;
Availability
Declared In
OpenTransport.h

No-Copy Receive Buffer Structure

Receives data without copying it.

struct OTBuffer {
   void * fLink;
   void * fLink2;
   OTBuffer * fNext;
   UInt8 * fData;
   ByteCount fLen;
   void * fSave;
   UInt8 fBand;
   UInt8 fType;
   UInt8 fPad1;
   UInt8 fFlags;
};
typedef struct OTBuffer OTBuffer;
Fields
fLink

Reserved.

fLink2

Reserved.

fNext

A pointer to the next OTBuffer structure in the linked chain. By tracing the chain of fNext pointers, you can access all of the data associated with the message.

fData

A pointer to the data portion of this OTBuffer structure.

fLen

The length of data pointed to by the fData field.

fSave

Reserved.

fBand

The band used for the data transmission. It must be a value between 0 and 255.

fType

The type of the data (normally M_DATA, M_PROTO, or M_PCPROTO).

fPad1

Reserved.

fFlags

The flags associated with the data (MSGMARK, MSGDELIM).

Discussion

You use the no-copy receive buffer structure when you wish to receive data without copying it with the OTRcvUData function, the OTRcvURequest function, the OTRcvUReply function, the OTRcv function, the OTRcvRequest function, and the OTRcvReply function.

If you are familiar with STREAMS mblk_t data structures, you can see that the no-copy receive buffer structure is just a slight modification of the mblk_t structure.

You can only use this buffer for data; you cannot use it for the address or options that may be associated with the incoming data. For example, in the case of an incoming TUnitData structure, you can only no-copy receive the udata portion, not the addr or opt fields.

Special Considerations

Under no circumstance write to this data structure. It is read-only. If you write to it, you can crash the system.

Availability
Declared In
OpenTransport.h

Buffer Information Structure

A convenience structure for keeping track of where your application left off in an OTBuffer structure.

struct OTBufferInfo {
   OTBuffer * fBuffer;
   ByteCount fOffset;
   UInt8 fPad;
};
typedef struct OTBufferInfo OTBufferInfo;
Fields
fBuffer

A pointer to the no-copy receive buffer.

fOffset

An offset indicating how far into the buffer you have read.

fPad

Reserved.

Discussion

The buffer information structure is provided for your convenience in keeping track of where you last left off in an OTBuffer structure. Because the no-copy receive buffer structure (OTBuffer) is read-only, you may need to copy the data in sections as you progress through the no-copy receive buffer. The utility function OTReadBuffer is used with this structure to easily copy the data out of an OTBuffer structure.

Availability
Declared In
OpenTransport.h

OTByteCount

typedef ByteCount OTByteCount;
Availability
Declared In
OpenTransport.h

OTClient

typedef struct OpaqueOTClient * OTClient;
Availability
Declared In
OpenTransport.h

OTClientContextPtr

typedef struct OpaqueOTClientContextPtr * OTClientContextPtr;
Availability
Declared In
OpenTransport.h

OTClientList

Identifies the clients that denied a request to yield a port.

struct OTClientList {
   ItemCount fNumClients;
   UInt8 fBuffer[4];
};
typedef struct OTClientList OTClientList;
Fields
fNumClients

The number of clients in the fBuffer array, normally 1.

fBuffer

An array of packed Pascal strings enumerating the name of each client that rejected the request—that is, the names under which the clients registered themselves as an Open Transport clients.

Availability
Declared In
OpenTransportProtocol.h

OTClientName

typedef UInt8 * OTClientName;
Availability
Declared In
OpenTransport.h

OTCommand

typedef SInt32 OTCommand;
Availability
Declared In
OpenTransport.h

OTConfigurationRef

typedef struct OTConfiguration * OTConfigurationRef;
Availability
Declared In
OpenTransport.h

OTData Structure

Specifies the location and size of noncontiguous data.

struct OTData {
   void * fNext;
   void * fData;
   ByteCount fLen;
};
typedef struct OTData OTData;
Fields
fNext

A pointer to the OTData structure that describes the next data fragment. Specify a NULL pointer for the last data fragment.

fData

A pointer to the data fragment.

fLen

Specifies the size of the fragment in bytes.

Discussion

The OTData structure is an Apple extension used to specify the location and size of noncontiguous data. You use a pointer to this structure in place of a pointer to continguous data normally referenced in TNetbuf.buf field. You can send discontiguous data using the OTSndUData function, the OTSndURequest function, the OTSndUReply function, the OTSnd function, the OTSndRequest function, and the OTSndReply function.

Each OTData structure specifies the location of a data fragment, the size of the fragment, and the location of the OTData structure that specifies the location and size of the next data fragment. The data information structure is defined by the OTData type. For more information, see “Sending Noncontiguous Data.”

Availability
Declared In
OpenTransport.h

OTDataSize

typedef SInt32 OTDataSize;
Availability
Declared In
OpenTransport.h

OTDeferredTaskRef

typedef long OTDeferredTaskRef;
Availability
Declared In
OpenTransport.h

OTEventCode

typedef UInt32 OTEventCode;
Availability
Declared In
OpenTransport.h

OTError

typedef SInt32 OTError;

OTGate

struct OTGate {
   OTLIFO fLIFO;
   OTList fList;
   OTGateProcPtr fProc;
   SInt32 fNumQueued;
   SInt32 fInside;
};
typedef struct OTGate OTGate;
Fields
fLIFO
fList
fProc
fNumQueued
fInside
Availability
Declared In
OpenTransportProtocol.h

OTHashList

struct OTHashList {
   OTHashProcPtr fHashProc;
   ByteCount fHashTableSize;
   OTLink ** fHashBuckets;
};
typedef struct OTHashList OTHashList;
Fields
fHashProc
fHashTableSize
fHashBuckets
Availability
Declared In
OpenTransportProtocol.h

OTInt32

typedef SInt32 OTInt32;
Availability
Declared In
OpenTransport.h

OTISDNAddress

struct OTISDNAddress {
   OTAddressType fAddressType;
   UInt16 fPhoneLength;
   char fPhoneNumber[37];
};
typedef struct OTISDNAddress OTISDNAddress;
Fields
fAddressType
fPhoneLength
fPhoneNumber
Availability
Declared In
OpenTransportProviders.h

OTItemCount

typedef ItemCount OTItemCount;
Availability
Declared In
OpenTransport.h

LIFO List Structure

Supports last-in, first-out lists in Open Transport.

struct OTLIFO {
   OTLink * fHead;
};
typedef struct OTLIFO OTLIFO;
Fields
fHead

A pointer to the first entry in the linked list. Set this to nil to initialize the structure before using it.

Discussion

Open Transport LIFO (last-in, first-out) lists use the LIFO list structure. You must initialize this structure by setting the structure’s fHead field to NULL before using the LIFO list. Most Open Transport LIFO list operations are atomic.

Availability
Declared In
OpenTransport.h

OTLink

Allows any data structure to be used in an Open Transport list.

struct OTLink {
   OTLink * fNext;
};
typedef struct OTLink OTLink;
Fields
fNext

A pointer to the next entry in the linked list.

Discussion

All of Open Transport’s list utilities use the linked list structure, which may be embedded in any data structure that you want to use in an Open Transport list. A linked list structure is defined by the OTLink data type.

Availability
Declared In
OpenTransport.h

FIFO List Structure

Supports first-in, last-out lists in Open Transport

struct OTList {
   OTLink * fHead;
};
typedef struct OTList OTList;
Fields
fHead

A pointer to the first entry in the linked list. Set this to NULL to initialize the structure before using it.

Discussion

Open Transport FIFO (first-in, first-out) lists use the FIFO list structure. You must initialize this structure by setting the structure’s fHead field to NULL before using the LIFO list. The FIFO list structure is defined by the OTList data type.

None of the functions that handle a FIFO list structure are atomic.

Availability
Declared In
OpenTransport.h

OTListSearchUPP

typedef OTListSearchProcPtr OTListSearchUPP;
Discussion

For more information, see the description of the OTListSearchUPP () callback function.

Availability
Declared In
OpenTransport.h

Lock Data Type

Defines a value used to ensure that Open Transport does not recursively reenter locked areas of code.

typedef UInt8 OTLock;
Discussion

The lock data type defines a value that is used by the OTClearLock function and the OTAcquireLock function to ensure that Open Transport does not recursively reenter locked areas of code. The lock data type is defined by the OTLock data type

Availability
Declared In
OpenTransport.h

OTNameID

typedef SInt32 OTNameID;
Availability
Declared In
OpenTransport.h

OTNotifyUPP

typedef OTNotifyProcPtr OTNotifyUPP;
Discussion

For more information, see the description of the OTNotifyUPP () callback function.

Availability
Declared In
OpenTransport.h

OTPCIInfo

struct OTPCIInfo {
   RegEntryID fTheID;
   void *fConfigurationInfo;
   ByteCount fConfigurationLength;
};
Fields

OTPortCloseStruct

Denies or accepts requests to yield a port.

struct OTPortCloseStruct {
   OTPortRef fPortRef;
   ProviderRef fTheProvider;
   OSStatus fDenyReason;
};
typedef struct OTPortCloseStruct OTPortCloseStruct;
Fields
fPortRef

The port requested to be closed.

fTheProvider

The provider that is currently using the port.

fDenyReason

A value that you can leave untouched to accept the yield request. To deny the request, change this value to a negative error code corresponding to the reason for your denial (normally you use the kOTUserRequestedErr error).

Discussion

When you are using a port that another client wishes to use, the other client can use the OTYieldPortRequest function (not available in Mac OS X) to ask you to yield the port. If you are registered as a client of Open Transport, you receive a kOTYieldPortRequest event, whose cookie parameter is a pointer to a port close structure. You can use this structure to deny or accept the yield request.

Currently, this callback is only used for serial ports, but it is applicable to any hardware device that cannot share a port with multiple clients. You should check the kOTCanYieldPort bit in the port structure’s fInfoFlags field to see whether the port supports yielding.

If the provider is passively listening (that is, bound with a queue length (qlen) greater than 0) and you are willing to yield, you need do nothing. If, however, you are actively connected and you are willing to yield the port, you must issue a synchronous OTSndDisconnect callin order to let the port go.

Availability
Declared In
OpenTransportProtocol.h

The Port Structure

Describes a port’s characteristics.

struct OTPortRecord {
   OTPortRef fRef;
   UInt32 fPortFlags;
   UInt32 fInfoFlags;
   UInt32 fCapabilities;
   ItemCount fNumChildPorts;
   OTPortRef * fChildPorts;
   char fPortName[36];
   char fModuleName[32];
   char fSlotID[8];
   char fResourceInfo[32];
   char fReserved[164];
};
typedef struct OTPortRecord OTPortRecord;
Fields
fRef

The port reference; a 32-bit value encoding the port’s device type, bus type, slot number, and multiport identifier

fPortFlags

Flags describing the port’s status. If no bits are set, the port is currently inactive—that is, it is not in use at this time.

fInfoFlags
fCapabilities
fNumChildPorts
fChildPorts

An array of the port references for the child ports associated with this port. When you get a Port Record, this pointer typically points into the SReserved field at the end of the record.

fPortName

A unique name for this port. The port name is a zero-terminated string that can have a maximum length as indicated by the constant kMaxProviderNameSize.

fModuleName

The name of the actual STREAMS module that implements the driver for this port. Open Transport uses this name internally; applications rarely need to use this name.

fSlotID

An 8-byte identifier for a port’s slot that contains a 7-byte character string plus a zero for termination. This identifier is typically available only for PCI cards.

fResourceInfo

A zero-terminated string that describes a shared library that can handle configuration information for the device. This field contains an identifier that allows Open Transport to access auxiliary information about the driver (Open Transport creates shared library IDs from this string to be able to find these extra shared libraries). This string should either be unique to the driver or should be set to a NULL string.

fReserved

Reserved.

Discussion

Open Transport uses a port structure to describe a port’s characteristics, such as its port name, its child ports, whether it is active or disabled, whether it is private or shareable, and the kind of framing it can use.

Availability
Declared In
OpenTransport.h

OTPortRef

typedef UInt32 OTPortRef;
Availability
Declared In
OpenTransport.h

OTProcessUPP

typedef OTProcessProcPtr OTProcessUPP;
Discussion

For more information, see the description of the OTProcessUPP () callback function.

Availability
Declared In
OpenTransport.h

OTQLen

typedef UInt32 OTQLen;
Availability
Declared In
OpenTransport.h

OTReadInfo

struct OTReadInfo {
   UInt32 fType;
   OTCommand fCommand;
   UInt32 fFiller;
   ByteCount fBytes;
   OSStatus fError;
};
typedef struct OTReadInfo OTReadInfo;
Fields
fType
fCommand
fFiller
fBytes
fError
Availability
Declared In
OpenTransportProtocol.h

OTReason

typedef SInt32 OTReason;
Availability
Declared In
OpenTransport.h

OTResourceLocator

struct OTResourceLocator {
   FSSpec fFile;
   UInt16 fResID;
};
typedef struct OTResourceLocator OTResourceLocator;
Fields
fFile
fResID
Availability
Declared In
OpenTransportProtocol.h

OTResult

typedef SInt32 OTResult;
Availability
Declared In
OpenTransport.h

OTScriptInfo

struct OTScriptInfo {
   UInt32 fScriptType;
   void * fTheScript;
   UInt32 fScriptLength;
};
typedef struct OTScriptInfo OTScriptInfo;
Fields
fScriptType
fTheScript
fScriptLength
Availability
Declared In
OpenTransport.h

OTSequence

typedef SInt32 OTSequence;
Availability
Declared In
OpenTransport.h

OTSInt16Param

typedef SInt16 OTSInt16Param;
Availability
Declared In
OpenTransport.h

OTSInt8Param

typedef SInt8 OTSInt8Param;
Availability
Declared In
OpenTransport.h

OTSlotNumber

typedef UInt16 OTSlotNumber;
Availability
Declared In
OpenTransport.h

OTStateMachine

struct OTStateMachine {
   OTStateMachineDataPad fData;
   void * fCookie;
   OTEventCode fCode;
   OTResult fResult;
};
typedef struct OTStateMachine OTStateMachine;
Fields
fData
fCookie
fCode
fResult
Availability
Declared In
OpenTransportProtocol.h

OTStateMachineDataPad

typedef UInt8 OTStateMachineDataPad[12];
Availability
Declared In
OpenTransportProtocol.h

OTSystemTaskRef

typedef  OTSystemTaskRef;
Availability
Declared In
OpenTransport.h

OTTimeout

typedef UInt32 OTTimeout;
Availability
Declared In
OpenTransport.h

OTTimerTask

typedef  OTTimerTask;
Availability
Declared In
OpenTransportProtocol.h

Timestamp Data Type

Contains an Open Transport timestamp.

typedef UnsignedWide OTTimeStamp;
Discussion

The timestamp data type is a 64-bit value that contains an Open Transport timestamp. The timestamp has unspecified units; you must use one of the timestamp manipulation functions described in “Timestamp Utility Functions” to convert the timestamp to known quantities. The timestamp data type is defined by the OTTimeStamp data type.

Availability
Declared In
OpenTransport.h

OTUInt16Param

typedef UInt16 OTUInt16Param;
Availability
Declared In
OpenTransport.h

OTUInt32

typedef UInt32 OTUInt32;
Availability
Declared In
OpenTransport.h

OTUInt8Param

typedef UInt8 OTUInt8Param;
Availability
Declared In
OpenTransport.h

OTUnixErr

typedef UInt16 OTUnixErr;
Availability
Declared In
OpenTransport.h

OTXTILevel

typedef UInt32 OTXTILevel;
Availability
Declared In
OpenTransport.h

OTXTIName

typedef UInt32 OTXTIName;
Availability
Declared In
OpenTransport.h

pollfd

struct pollfd {
   SInt32 fd;
   SInt16 events;
   SInt16 revents;
   SInt32 _ifd;
};
Fields

PollRef

struct PollRef {
   SInt32 filler;
   SInt16 events;
   SInt16 revents;
   StreamRef ref;
};
typedef struct PollRef PollRef;
Fields
filler
events
revents
ref
Availability
Declared In
OpenTransportProtocol.h

PPPMRULimits

struct PPPMRULimits {
   UInt32 mruSize;
   UInt32 upperMRULimit;
   UInt32 lowerMRULimit;
};
typedef struct PPPMRULimits PPPMRULimits;
Fields
mruSize
upperMRULimit
lowerMRULimit
Availability
Declared In
OpenTransportProviders.h

ProviderRef

typedef struct OpaqueProviderRef * ProviderRef;
Availability
Declared In
OpenTransport.h

q_xtra

struct q_xtra {
   UInt32 dummy;
};
typedef struct q_xtra q_xtra;
Fields
dummy
Availability
Declared In
OpenTransportProtocol.h

qband

struct qband {
   qband * qb_next;
   unsigned long qb_count;
   msgb * qb_first;
   msgb * qb_last;
   unsigned long qb_hiwat;
   unsigned long qb_lowat;
   unsigned short qb_flag;
   short qb_pad1;
};
typedef struct qband qband;
typedef qband qband_t;
Fields
qb_next
qb_count
qb_first
qb_last
qb_hiwat
qb_lowat
qb_flag
qb_pad1
Availability
Declared In
OpenTransportProtocol.h

qband_t

typedef qband qband_t;
Availability
Declared In
OpenTransportProtocol.h

qfields_t

typedef qfields qfields_t;
Availability
Declared In
OpenTransportProtocol.h

qinit

struct qinit {
   putp_t qi_putp;
   srvp_t qi_srvp;
   openp_t qi_qopen;
   closep_t qi_qclose;
   admin_t qi_qadmin;
   module_info * qi_minfo;
   module_stat * qi_mstat;
};
typedef struct qinit qinit;
Fields
qi_putp
qi_srvp
qi_qopen
qi_qclose
qi_qadmin
qi_minfo
qi_mstat
Availability
Declared In
OpenTransportProtocol.h

queue

struct queue {
   qinit * q_qinfo;
   msgb * q_first;
   msgb * q_last;
   queue * q_next;
   queue_q_u q_u;
   char * q_ptr;
   unsigned long q_count;
   long q_minpsz;
   long q_maxpsz;
   unsigned long q_hiwat;
   unsigned long q_lowat;
   qband * q_bandp;
   unsigned short q_flag;
   unsigned char q_nband;
   unsigned char q_pad1[1];
   q_xtra * q_osx;
   queue * q_ffcp;
   queue * q_bfcp;
};
typedef struct queue queue;
typedef queue * queuePtr;
Fields
q_qinfo
q_first
q_last
q_next
q_u
q_ptr
q_count
q_minpsz
q_maxpsz
q_hiwat
q_lowat
q_bandp
q_flag
q_nband
q_pad1
q_osx
q_ffcp
q_bfcp
Availability
Declared In
OpenTransportProtocol.h

queue_q_u

union queue_q_u {
   queue * q_u_link;
   sqh_s * q_u_sqh_parent;
};
typedef union queue_q_u queue_q_u;
Fields
q_u_link
q_u_sqh_parent
Availability
Declared In
OpenTransportProtocol.h

queue_t

typedef SInt32 queue_t;
Availability
Declared In
queue.h

short_p

typedef SInt16 short_p;
Availability
Declared In
OpenTransport.h

sqh_s

struct sqh_s {
   UInt32 dummy;
};
typedef struct sqh_s sqh_s;
Fields
dummy
Availability
Declared In
OpenTransportProtocol.h

sth_s

struct sth_s {
   UInt32 dummy;
};
typedef struct sth_s sth_s;
Fields
dummy
Availability
Declared In
OpenTransportProtocol.h

str_list

struct str_list {
   SInt32 sl_nmods;
   str_mlist * sl_modlist;
};
typedef struct str_list str_list;
Fields
sl_nmods
sl_modlist
Availability
Declared In
OpenTransportProtocol.h

str_mlist

struct str_mlist {
   char l_name[32];
};
typedef struct str_mlist str_mlist;
Fields
l_name
Availability
Declared In
OpenTransportProtocol.h

strbuf

struct strbuf {
   SInt32 maxlen;
   SInt32 len;
   char * buf;
};
typedef struct strbuf strbuf;
Fields
maxlen
len
buf
Availability
Declared In
OpenTransport.h

StreamRef

typedef struct OpaqueStreamRef * StreamRef;
Availability
Declared In
OpenTransportProtocol.h

streamtab

struct streamtab {
   qinit * st_rdinit;
   qinit * st_wrinit;
   qinit * st_muxrinit;
   qinit * st_muxwinit;
};
typedef struct streamtab streamtab;
Fields
st_rdinit
st_wrinit
st_muxrinit
st_muxwinit
Availability
Declared In
OpenTransportProtocol.h

strfdinsert

struct strfdinsert {
   strbuf ctlbuf;
   strbuf databuf;
   long flags;
   long fildes;
   SInt32 offset;
};
typedef struct strfdinsert strfdinsert;
Fields
ctlbuf
databuf
flags
fildes
offset
Availability
Declared In
OpenTransportProtocol.h

strioctl

struct strioctl {
   SInt32 ic_cmd;
   SInt32 ic_timout;
   SInt32 ic_len;
   char * ic_dp;
};
typedef struct strioctl strioctl;
Fields
ic_cmd
ic_timout
ic_len
ic_dp
Availability
Declared In
OpenTransportProtocol.h

stroptions

struct stroptions {
   unsigned long so_flags;
   short so_readopt;
   unsigned short so_wroff;
   long so_minpsz;
   long so_maxpsz;
   unsigned long so_hiwat;
   unsigned long so_lowat;
   unsigned char so_band;
   unsigned char so_filler[3];
   unsigned long so_poll_set;
   unsigned long so_poll_clr;
};
typedef struct stroptions stroptions;
Fields
so_flags
so_readopt
so_wroff
so_minpsz
so_maxpsz
so_hiwat
so_lowat
so_band
so_filler
so_poll_set
so_poll_clr
Availability
Declared In
OpenTransportProtocol.h

strpeek

struct strpeek {
   strbuf ctlbuf;
   strbuf databuf;
   long flags;
};
typedef struct strpeek strpeek;
Fields
ctlbuf
databuf
flags
Availability
Declared In
OpenTransportProtocol.h

strpfp

struct strpfp {
   unsigned long pass_file_cookie;
   unsigned short pass_uid;
   unsigned short pass_gid;
   sth_s * pass_sth;
};
typedef struct strpfp strpfp;
Fields
pass_file_cookie
pass_uid
pass_gid
pass_sth
Availability
Declared In
OpenTransportProtocol.h

strpmsg

struct strpmsg {
   strbuf ctlbuf;
   strbuf databuf;
   SInt32 band;
   long flags;
};
typedef struct strpmsg strpmsg;
Fields
ctlbuf
databuf
band
flags
Availability
Declared In
OpenTransportProtocol.h

strrecvfd

struct strrecvfd {
   long fd;
   unsigned short uid;
   unsigned short gid;
   char fill[8];
};
typedef struct strrecvfd strrecvfd;
Fields
fd
uid
gid
fill
Availability
Declared In
OpenTransportProtocol.h

T_addr_ack

struct T_addr_ack {
   long PRIM_type;
   long LOCADDR_length;
   long LOCADDR_offset;
   long REMADDR_length;
   long REMADDR_offset;
};
typedef struct T_addr_ack T_addr_ack;
Fields
PRIM_type
LOCADDR_length
LOCADDR_offset
REMADDR_length
REMADDR_offset
Availability
Declared In
OpenTransportProtocol.h

T_addr_req

struct T_addr_req {
   long PRIM_type;
};
typedef struct T_addr_req T_addr_req;
Fields
PRIM_type
Availability
Declared In
OpenTransportProtocol.h

T_bind_ack

struct T_bind_ack {
   long PRIM_type;
   long ADDR_length;
   long ADDR_offset;
   unsigned long CONIND_number;
};
typedef struct T_bind_ack T_bind_ack;
Fields
PRIM_type
ADDR_length
ADDR_offset
CONIND_number
Availability
Declared In
OpenTransportProtocol.h

T_bind_req

struct T_bind_req {
   long PRIM_type;
   long ADDR_length;
   long ADDR_offset;
   unsigned long CONIND_number;
};
typedef struct T_bind_req T_bind_req;
Fields
PRIM_type
ADDR_length
ADDR_offset
CONIND_number
Availability
Declared In
OpenTransportProtocol.h

t_call


Fields

T_cancelreply_req

struct T_cancelreply_req {
   long PRIM_type;
   long SEQ_number;
};
typedef struct T_cancelreply_req T_cancelreply_req;
Fields
PRIM_type
SEQ_number
Availability
Declared In
OpenTransportProtocol.h

T_cancelrequest_req

struct T_cancelrequest_req {
   long PRIM_type;
   long SEQ_number;
};
typedef struct T_cancelrequest_req T_cancelrequest_req;
Fields
PRIM_type
SEQ_number
Availability
Declared In
OpenTransportProtocol.h

T_conn_con

struct T_conn_con {
   long PRIM_type;
   long RES_length;
   long RES_offset;
   long OPT_length;
   long OPT_offset;
};
typedef struct T_conn_con T_conn_con;
Fields
PRIM_type
RES_length
RES_offset
OPT_length
OPT_offset
Availability
Declared In
OpenTransportProtocol.h

T_conn_ind

struct T_conn_ind {
   long PRIM_type;
   long SRC_length;
   long SRC_offset;
   long OPT_length;
   long OPT_offset;
   long SEQ_number;
};
typedef struct T_conn_ind T_conn_ind;
Fields
PRIM_type
SRC_length
SRC_offset
OPT_length
OPT_offset
SEQ_number
Availability
Declared In
OpenTransportProtocol.h

T_conn_req

struct T_conn_req {
   long PRIM_type;
   long DEST_length;
   long DEST_offset;
   long OPT_length;
   long OPT_offset;
};
typedef struct T_conn_req T_conn_req;
Fields
PRIM_type
DEST_length
DEST_offset
OPT_length
OPT_offset
Availability
Declared In
OpenTransportProtocol.h

T_conn_res

struct T_conn_res {
   long PRIM_type;
   queue_t * QUEUE_ptr;
   long OPT_length;
   long OPT_offset;
   long SEQ_number;
};
typedef struct T_conn_res T_conn_res;
Fields
PRIM_type
QUEUE_ptr
OPT_length
OPT_offset
SEQ_number
Availability
Declared In
OpenTransportProtocol.h

T_data_ind

struct T_data_ind {
   long PRIM_type;
   long MORE_flag;
};
typedef struct T_data_ind T_data_ind;
Fields
PRIM_type
MORE_flag
Availability
Declared In
OpenTransportProtocol.h

T_data_req

struct T_data_req {
   long PRIM_type;
   long MORE_flag;
};
typedef struct T_data_req T_data_req;
Fields
PRIM_type
MORE_flag
Availability
Declared In
OpenTransportProtocol.h

T_delname_req

struct T_delname_req {
   long PRIM_type;
   long SEQ_number;
   long NAME_length;
   long NAME_offset;
};
typedef struct T_delname_req T_delname_req;
Fields
PRIM_type
SEQ_number
NAME_length
NAME_offset
Availability
Declared In
OpenTransportProtocol.h

t_discon


Fields

T_discon_ind

struct T_discon_ind {
   long PRIM_type;
   long DISCON_reason;
   long SEQ_number;
};
typedef struct T_discon_ind T_discon_ind;
Fields
PRIM_type
DISCON_reason
SEQ_number
Availability
Declared In
OpenTransportProtocol.h

T_discon_req

struct T_discon_req {
   long PRIM_type;
   long SEQ_number;
};
typedef struct T_discon_req T_discon_req;
Fields
PRIM_type
SEQ_number
Availability
Declared In
OpenTransportProtocol.h

T_error_ack

struct T_error_ack {
   long PRIM_type;
   long ERROR_prim;
   long TLI_error;
   long UNIX_error;
};
typedef struct T_error_ack T_error_ack;
Fields
PRIM_type
ERROR_prim
TLI_error
UNIX_error
Availability
Declared In
OpenTransportProtocol.h

T_event_ind

struct T_event_ind {
   long PRIM_type;
   long EVENT_code;
   long EVENT_cookie;
};
typedef struct T_event_ind T_event_ind;
Fields
PRIM_type
EVENT_code
EVENT_cookie
Availability
Declared In
OpenTransportProtocol.h

T_exdata_ind

struct T_exdata_ind {
   long PRIM_type;
   long MORE_flag;
};
typedef struct T_exdata_ind T_exdata_ind;
Fields
PRIM_type
MORE_flag
Availability
Declared In
OpenTransportProtocol.h

T_exdata_req

struct T_exdata_req {
   long PRIM_type;
   long MORE_flag;
};
typedef struct T_exdata_req T_exdata_req;
Fields
PRIM_type
MORE_flag
Availability
Declared In
OpenTransportProtocol.h

t_info


Fields

T_info_ack

struct T_info_ack {
   long PRIM_type;
   long TSDU_size;
   long ETSDU_size;
   long CDATA_size;
   long DDATA_size;
   long ADDR_size;
   long OPT_size;
   long TIDU_size;
   long SERV_type;
   long CURRENT_state;
   long PROVIDER_flag;
};
typedef struct T_info_ack T_info_ack;
Fields
PRIM_type
TSDU_size
ETSDU_size
CDATA_size
DDATA_size
ADDR_size
OPT_size
TIDU_size
SERV_type
CURRENT_state
PROVIDER_flag
Availability
Declared In
OpenTransportProtocol.h

T_info_req

struct T_info_req {
   long PRIM_type;
};
typedef struct T_info_req T_info_req;
Fields
PRIM_type
Availability
Declared In
OpenTransportProtocol.h

The Keepalive Structure

Specifies the value of the OPT_KEEPALIVE option.

struct t_kpalive {
   SInt32 kp_onoff;
   SInt32 kp_timeout;
};
typedef struct t_kpalive t_kpalive;
Fields
kp_onoff

A constant specifying whether the option is turned on (T_ON) or off (T_OFF).

kp_timeout

A positive integer specifying how many minutes Open Transport should maintain a connection in the absence of traffic.

Discussion

The keepalive structure specifies the value of the OPT_KEEPALIVE option, described in “XTI-Level Options and Generic Options”

Availability
Declared In
OpenTransport.h

The Linger Structure

Specifies the value of the XTI_LINGER option.

struct t_linger {
   SInt32 l_onoff;
   SInt32 l_linger;
};
typedef struct t_linger t_linger;
Fields
l_onoff

A constant specifying whether the option is turned on (T_ON) or off (T_OFF).

l_linger

An integer specifying the linger time, the amount of time in seconds that Open Transport should wait to allow data in an endpoint’s internal buffer to be sent before the OTCloseProvider function closes the endpoint.

To request the default value for this option, set the l_linger field to T_UNSPEC.

Discussion

The linger structure specifies the value of the XTI_LINGER option, described in “XTI-Level Options and Generic Options.”

Availability
Declared In
OpenTransport.h

T_lkupname_con

struct T_lkupname_con {
   long PRIM_type;
   long SEQ_number;
   long NAME_length;
   long NAME_offset;
   long RSP_count;
   long RSP_cumcount;
};
typedef struct T_lkupname_con T_lkupname_con;
Fields
PRIM_type
SEQ_number
NAME_length
NAME_offset
RSP_count
RSP_cumcount
Availability
Declared In
OpenTransportProtocol.h

T_lkupname_req

struct T_lkupname_req {
   long PRIM_type;
   long SEQ_number;
   long NAME_length;
   long NAME_offset;
   long ADDR_length;
   long ADDR_offset;
   long MAX_number;
   long MAX_milliseconds;
   long REQ_flags;
};
typedef struct T_lkupname_req T_lkupname_req;
Fields
PRIM_type
SEQ_number
NAME_length
NAME_offset
ADDR_length
ADDR_offset
MAX_number
MAX_milliseconds
REQ_flags
Availability
Declared In
OpenTransportProtocol.h

T_MIB_ack


Fields

T_MIB_req


Fields

T_ok_ack

struct T_ok_ack {
   long PRIM_type;
   long CORRECT_prim;
};
typedef struct T_ok_ack T_ok_ack;
Fields
PRIM_type
CORRECT_prim
Availability
Declared In
OpenTransportProtocol.h

t_opthdr


Fields

T_optmgmt_ack

struct T_optmgmt_ack {
   long PRIM_type;
   long OPT_length;
   long OPT_offset;
   long MGMT_flags;
};
typedef struct T_optmgmt_ack T_optmgmt_ack;
Fields
PRIM_type
OPT_length
OPT_offset
MGMT_flags
Availability
Declared In
OpenTransportProtocol.h

T_optmgmt_req

struct T_optmgmt_req {
   long PRIM_type;
   long OPT_length;
   long OPT_offset;
   long MGMT_flags;
};
typedef struct T_optmgmt_req T_optmgmt_req;
Fields
PRIM_type
OPT_length
OPT_offset
MGMT_flags
Availability
Declared In
OpenTransportProtocol.h

T_ordrel_ind

struct T_ordrel_ind {
   long PRIM_type;
};
typedef struct T_ordrel_ind T_ordrel_ind;
Fields
PRIM_type
Availability
Declared In
OpenTransportProtocol.h

T_ordrel_req

struct T_ordrel_req {
   long PRIM_type;
};
typedef struct T_ordrel_req T_ordrel_req;
Fields
PRIM_type
Availability
Declared In
OpenTransportProtocol.h

T_primitives

union T_primitives {
   long primType;
   T_addr_ack taddrack;
   T_bind_ack tbindack;
   T_bind_req tbindreq;
   T_conn_con tconncon;
   T_conn_ind tconnind;
   T_conn_req tconnreq;
   T_conn_res tconnres;
   T_data_ind tdataind;
   T_data_req tdatareq;
   T_discon_ind tdisconind;
   T_discon_req tdisconreq;
   T_exdata_ind texdataind;
   T_exdata_req texdatareq;
   T_error_ack terrorack;
   T_info_ack tinfoack;
   T_info_req tinforeq;
   T_ok_ack tokack;
   T_optmgmt_ack toptmgmtack;
   T_optmgmt_req toptmgmtreq;
   T_ordrel_ind tordrelind;
   T_ordrel_req tordrelreq;
   T_unbind_req tunbindreq;
   T_uderror_ind tuderrorind;
   T_unitdata_ind tunitdataind;
   T_unitdata_req tunitdatareq;
   T_unitreply_ind tunitreplyind;
   T_unitrequest_ind tunitrequestind;
   T_unitrequest_req tunitrequestreq;
   T_unitreply_req tunitreplyreq;
   T_unitreply_ack tunitreplyack;
   T_reply_ind treplyind;
   T_request_ind trequestind;
   T_request_req trequestreq;
   T_reply_req treplyreq;
   T_reply_ack treplyack;
   T_cancelrequest_req tcancelreqreq;
   T_resolveaddr_req tresolvereq;
   T_resolveaddr_ack tresolveack;
   T_regname_req tregnamereq;
   T_regname_ack tregnameack;
   T_delname_req tdelnamereq;
   T_lkupname_req tlkupnamereq;
   T_lkupname_con tlkupnamecon;
   T_sequence_ack tsequenceack;
   T_event_ind teventind;
};
typedef union T_primitives T_primitives;
Fields
primType
taddrack
tbindack
tbindreq
tconncon
tconnind
tconnreq
tconnres
tdataind
tdatareq
tdisconind
tdisconreq
texdataind
texdatareq
terrorack
tinfoack
tinforeq
tokack
toptmgmtack
toptmgmtreq
tordrelind
tordrelreq
tunbindreq
tuderrorind
tunitdataind
tunitdatareq
tunitreplyind
tunitrequestind
tunitrequestreq
tunitreplyreq
tunitreplyack
treplyind
trequestind
trequestreq
treplyreq
treplyack
tcancelreqreq
tresolvereq
tresolveack
tregnamereq
tregnameack
tdelnamereq
tlkupnamereq
tlkupnamecon
tsequenceack
teventind
Availability
Declared In
OpenTransportProtocol.h

T_regname_ack

struct T_regname_ack {
   long PRIM_type;
   long SEQ_number;
   long REG_id;
   long ADDR_length;
   long ADDR_offset;
};
typedef struct T_regname_ack T_regname_ack;
Fields
PRIM_type
SEQ_number
REG_id
ADDR_length
ADDR_offset
Availability
Declared In
OpenTransportProtocol.h

T_regname_req

struct T_regname_req {
   long PRIM_type;
   long SEQ_number;
   long NAME_length;
   long NAME_offset;
   long ADDR_length;
   long ADDR_offset;
   long REQ_flags;
};
typedef struct T_regname_req T_regname_req;
Fields
PRIM_type
SEQ_number
NAME_length
NAME_offset
ADDR_length
ADDR_offset
REQ_flags
Availability
Declared In
OpenTransportProtocol.h

t_reply


Fields

T_reply_ack

struct T_reply_ack {
   long PRIM_type;
   long SEQ_number;
   long TLI_error;
   long UNIX_error;
};
typedef struct T_reply_ack T_reply_ack;
Fields
PRIM_type
SEQ_number
TLI_error
UNIX_error
Availability
Declared In
OpenTransportProtocol.h

T_reply_ind

struct T_reply_ind {
   long PRIM_type;
   long SEQ_number;
   long OPT_length;
   long OPT_offset;
   long REP_flags;
   long TLI_error;
   long UNIX_error;
};
typedef struct T_reply_ind T_reply_ind;
Fields
PRIM_type
SEQ_number
OPT_length
OPT_offset
REP_flags
TLI_error
UNIX_error
Availability
Declared In
OpenTransportProtocol.h

T_reply_req

struct T_reply_req {
   long PRIM_type;
   long SEQ_number;
   long OPT_length;
   long OPT_offset;
   long REP_flags;
};
typedef struct T_reply_req T_reply_req;
Fields
PRIM_type
SEQ_number
OPT_length
OPT_offset
REP_flags
Availability
Declared In
OpenTransportProtocol.h

t_request


Fields

T_request_ind

struct T_request_ind {
   long PRIM_type;
   long SEQ_number;
   long OPT_length;
   long OPT_offset;
   long REQ_flags;
};
typedef struct T_request_ind T_request_ind;
Fields
PRIM_type
SEQ_number
OPT_length
OPT_offset
REQ_flags
Availability
Declared In
OpenTransportProtocol.h

T_request_req

struct T_request_req {
   long PRIM_type;
   long SEQ_number;
   long OPT_length;
   long OPT_offset;
   long REQ_flags;
};
typedef struct T_request_req T_request_req;
Fields
PRIM_type
SEQ_number
OPT_length
OPT_offset
REQ_flags
Availability
Declared In
OpenTransportProtocol.h

T_resolveaddr_ack

struct T_resolveaddr_ack {
   long PRIM_type;
   long SEQ_number;
   long ADDR_length;
   long ADDR_offset;
   long ORIG_client;
   long ORIG_data;
   long TLI_error;
   long UNIX_error;
};
typedef struct T_resolveaddr_ack T_resolveaddr_ack;
Fields
PRIM_type
SEQ_number
ADDR_length
ADDR_offset
ORIG_client
ORIG_data
TLI_error
UNIX_error
Availability
Declared In
OpenTransportProtocol.h

T_resolveaddr_req

struct T_resolveaddr_req {
   long PRIM_type;
   long SEQ_number;
   long ADDR_length;
   long ADDR_offset;
   long ORIG_client;
   long ORIG_data;
   long MAX_milliseconds;
};
typedef struct T_resolveaddr_req T_resolveaddr_req;
Fields
PRIM_type
SEQ_number
ADDR_length
ADDR_offset
ORIG_client
ORIG_data
MAX_milliseconds
Availability
Declared In
OpenTransportProtocol.h

T_sequence_ack

struct T_sequence_ack {
   long PRIM_type;
   long ORIG_prim;
   long SEQ_number;
   long TLI_error;
   long UNIX_error;
};
typedef struct T_sequence_ack T_sequence_ack;
Fields
PRIM_type
ORIG_prim
SEQ_number
TLI_error
UNIX_error
Availability
Declared In
OpenTransportProtocol.h

T_stream_timer


Fields

T_stream_timer_1


Fields

t_uderr


Fields

T_uderror_ind

struct T_uderror_ind {
   long PRIM_type;
   long DEST_length;
   long DEST_offset;
   long OPT_length;
   long OPT_offset;
   long ERROR_type;
};
typedef struct T_uderror_ind T_uderror_ind;
Fields
PRIM_type
DEST_length
DEST_offset
OPT_length
OPT_offset
ERROR_type
Availability
Declared In
OpenTransportProtocol.h

T_unbind_req

struct T_unbind_req {
   long PRIM_type;
};
typedef struct T_unbind_req T_unbind_req;
Fields
PRIM_type
Availability
Declared In
OpenTransportProtocol.h

t_unitdata


Fields

T_unitdata_ind

struct T_unitdata_ind {
   long PRIM_type;
   long SRC_length;
   long SRC_offset;
   long OPT_length;
   long OPT_offset;
};
typedef struct T_unitdata_ind T_unitdata_ind;
Fields
PRIM_type
SRC_length
SRC_offset
OPT_length
OPT_offset
Availability
Declared In
OpenTransportProtocol.h

T_unitdata_req

struct T_unitdata_req {
   long PRIM_type;
   long DEST_length;
   long DEST_offset;
   long OPT_length;
   long OPT_offset;
};
typedef struct T_unitdata_req T_unitdata_req;
Fields
PRIM_type
DEST_length
DEST_offset
OPT_length
OPT_offset
Availability
Declared In
OpenTransportProtocol.h

t_unitreply


Fields

T_unitreply_ack

struct T_unitreply_ack {
   long PRIM_type;
   long SEQ_number;
   long TLI_error;
   long UNIX_error;
};
typedef struct T_unitreply_ack T_unitreply_ack;
Fields
PRIM_type
SEQ_number
TLI_error
UNIX_error
Availability
Declared In
OpenTransportProtocol.h

T_unitreply_ind

struct T_unitreply_ind {
   long PRIM_type;
   long SEQ_number;
   long OPT_length;
   long OPT_offset;
   long REP_flags;
   long TLI_error;
   long UNIX_error;
};
typedef struct T_unitreply_ind T_unitreply_ind;
Fields
PRIM_type
SEQ_number
OPT_length
OPT_offset
REP_flags
TLI_error
UNIX_error
Availability
Declared In
OpenTransportProtocol.h

T_unitreply_req

struct T_unitreply_req {
   long PRIM_type;
   long SEQ_number;
   long OPT_length;
   long OPT_offset;
   long REP_flags;
};
typedef struct T_unitreply_req T_unitreply_req;
Fields
PRIM_type
SEQ_number
OPT_length
OPT_offset
REP_flags
Availability
Declared In
OpenTransportProtocol.h

t_unitrequest


Fields

T_unitrequest_ind

struct T_unitrequest_ind {
   long PRIM_type;
   long SEQ_number;
   long SRC_length;
   long SRC_offset;
   long OPT_length;
   long OPT_offset;
   long REQ_flags;
};
typedef struct T_unitrequest_ind T_unitrequest_ind;
Fields
PRIM_type
SEQ_number
SRC_length
SRC_offset
OPT_length
OPT_offset
REQ_flags
Availability
Declared In
OpenTransportProtocol.h

T_unitrequest_req

struct T_unitrequest_req {
   long PRIM_type;
   long SEQ_number;
   long DEST_length;
   long DEST_offset;
   long OPT_length;
   long OPT_offset;
   long REQ_flags;
};
typedef struct T_unitrequest_req T_unitrequest_req;
Fields
PRIM_type
SEQ_number
DEST_length
DEST_offset
OPT_length
OPT_offset
REQ_flags
Availability
Declared In
OpenTransportProtocol.h

T8022Address

struct T8022Address {
   OTAddressType fAddrFamily;
   UInt8 fHWAddr[6];
   UInt16 fSAP;
   UInt8 fSNAP[5];
};
typedef struct T8022Address T8022Address;
Fields
fAddrFamily
fHWAddr
fSAP
fSNAP
Availability
Declared In
OpenTransportProviders.h

T8022FullPacketHeader

struct T8022FullPacketHeader {
   EnetPacketHeader fEnetPart;
   T8022SNAPHeader f8022Part;
};
typedef struct T8022FullPacketHeader T8022FullPacketHeader;
Fields
fEnetPart
f8022Part
Availability
Declared In
OpenTransportProviders.h

T8022Header

struct T8022Header {
   UInt8 fDSAP;
   UInt8 fSSAP;
   UInt8 fCtrl;
};
typedef struct T8022Header T8022Header;
Fields
fDSAP
fSSAP
fCtrl
Availability
Declared In
OpenTransportProviders.h

T8022SNAPHeader

struct T8022SNAPHeader {
   UInt8 fDSAP;
   UInt8 fSSAP;
   UInt8 fCtrl;
   UInt8 fSNAP[5];
};
typedef struct T8022SNAPHeader T8022SNAPHeader;
Fields
fDSAP
fSSAP
fCtrl
fSNAP
Availability
Declared In
OpenTransportProviders.h

TBind

Describes the protocol address to which an endpoint is currently bound or connected, or specifies the protocol address to which you wish to bind or connect the endpoint.

struct TBind {
   TNetbuf addr;
   OTQLen qlen;
};
typedef struct TBind TBind;
Fields
addr

A TNetbuf structure that contains information about an address. The addr.maxlen field specifies the maximum size of the address, the addr.len field specifies the actual length of the address, and the addr.buf field points to the buffer containing the address.

When specifying an address, you must allocate a buffer for the address and initialize it; you must set the addr.buf field to point to this buffer; and you must set the addr.len field to the size of the address.

When requesting an address, you must allocate a buffer in which the address is to be placed; you must set the addr.buf field to point to this buffer; and you must set the addr.maxlen field to the maximum size of the address that is being returned. You determine this value by examining the addr field of the TEndpointInfo structure for the endpoint.

qlen

For a connection-oriented endpoint, the maximum number of connection requests that can be concurrently outstanding for this endpoint. For more information, see the description of the OTBind function. For connectionless endpoints, this field has no meaning.

Discussion

The TBind structure describes the protocol address to which an endpoint is currently bound or connected, or specifies the protocol address to which you wish to bind or connect the endpoint. For a connection-oriented endpoint, the TBind structure also specifies the actual or desired number of connection requests that can be concurrently outstanding for the endpoint.

You pass the TBind structure as a parameter to the OTBind function, the OTGetProtAddress function, and the OTResolveAddress function.

Availability
Declared In
OpenTransport.h

TCall

Specifies the options and data associated with establishing a connection.

struct TCall {
   TNetbuf addr;
   TNetbuf opt;
   TNetbuf udata;
   OTSequence sequence;
};
typedef struct TCall TCall;
Fields
addr

A TNetbuf structure that specifies the location and size of an address buffer

opt

A TNetbuf structure that specifies the location and size of an options buffer.

udata

A TNetbuf structure that specifies the location and size of a buffer for data associated with a connection or disconnection request.

sequence

A 32-bit value used by the OTListen and OTAccept functions to specify the connection ID.

Discussion

You use the TCall structure to specify the options and data associated with establishing a connection. You pass a pointer to this structure as a parameter to the OTConnect function, the OTRcvConnect function, the OTListen function, and the OTAccept function.

If you are using the TCall structure to send information, you must allocate a buffer and initialize it to contain the information. Set the .buf field of each TNetbuf to point to the buffer, and then specify the size of the buffer using the .len field. Set this field to 0 if you are not sending data.

If you are using the TCall structure to receive information, you must allocate a buffer into which the function can place the information when it returns. Then set the .buf field of all the TNetbufs to point to this buffer, and set the .maxlen field to the maximum size of the information. Set this field to 0 if you are not interested in receiving information.

Availability
Declared In
OpenTransport.h

TDiscon

Specifies data sent with the OTSndDisconnect function and retrieved by the OTRcvDisconnect function.

struct TDiscon {
   TNetbuf udata;
   OTReason reason;
   OTSequence sequence;
};
typedef struct TDiscon TDiscon;
Fields
udata

A TNetbuf structure that references data sent with the OTSndDisconnect function or received by the OTRcvDisconnect function.

reason

A 32-bit value specifying an error code that identifies the reason for the disconnection. These codes are supplied by the protocol. For additional information, consult the documentation provided for the protocol you are using.

sequence

A 32-bit value specifying an outstanding connection request that has been rejected. This field is meaningful only when you have issued several connection requests to the same endpoint and are awaiting the results.

Availability
Declared In
OpenTransport.h

TEndpointInfo

Describes the initial characteristics of an endpoint that you opened by calling the OTOpenEndpointInContext function; returned by calling OTGetEndpointInfo.

struct TEndpointInfo {
   OTDataSize addr;
   OTDataSize options;
   OTDataSize tsdu;
   OTDataSize etsdu;
   OTDataSize connect;
   OTDataSize discon;
   OTServiceType servtype;
   UInt32 flags;
};
typedef struct TEndpointInfo TEndpointInfo;
Fields
addr
options

A value greater than or equal to 0 indicates the maximum number of bytes needed to store the protocol-specific options that this endpoint supports, if any. A value of T_INVALID (-2) indicates that this endpoint has no protocol-specific options that you can set; they are read-only. A value of -3 specifies that the provider does not support any options.

tsdu

For a transactionless endpoint, a positive value indicates the maximum number of bytes in a transport service data unit (TSDU) for this endpoint. A value of T_INFINITE (-1) indicates that there is no limit to the size of a TSDU. A value of 0 indicates that the provider does not support the concept of a TSDU. This means that you cannot send data with logical boundaries preserved across a connection. A value of T_INVALID indicates that this endpoint cannot transfer normal data (as opposed to expedited data).

For a transaction-based endpoint, this field indicates the maximum number of bytes in a response.

etsdu

For a transactionless endpoint, a positive value indicates the maximum number of bytes in an expedited transport service data unit (ETSDU) for this endpoint. A value of T_INFINITE indicates that there is no limit to the size of a ETSDU. A value of 0 indicates that this endpoint does not support the concept of an ETSDU. This means that you must not send expedited data with logical boundaries preserved across a connection. A value of T_INVALID indicates that this endpoint cannot transfer expedited data.

For a transaction-based endpoint, this field indicates the maximum number of bytes in a request.

connect

For a connection-oriented endpoint, a value greater than or equal to 0 indicates the maximum amount of data (in bytes) that you can send with the OTConnect function or the OTAccept function. A value of T_INVALID indicates that this endpoint does not let you send data with these functions. This field is meaningless for other types of endpoints.

discon

For a connection-oriented endpoint, a value greater than or equal to 0 indicates the maximum amount of data (in bytes) that you can send using the OTSndDisconnect function. A value of T_INVALID indicates that this endpoint does not let you send data with disconnection requests. This field is meaningless for other types of endpoints.

servtype

A constant that indicates what kind of service the endpoint provides. Possible values are given by the “Endpoint Service Types” enumeration.

flags

A bit FIeld that provides additional information about the endpoint. Possible values are given by the “Endpoint Flags” enumeration.

Availability
Declared In
OpenTransport.h

IP Multicast Address Structure

Supports adding and dropping membership in an IP multicast address.

struct TIPAddMulticast {
   InetHost multicastGroupAddress;
   InetHost interfaceAddress;
};
typedef struct TIPAddMulticast TIPAddMulticast;
Fields
multicastGroupAddress

The IP address of the multicast group for which you want to add or drop membership.

interfaceAddress

The IP address of the network interface that you are using for the multicast group.

Discussion

You use the IP multicast address structure with the IP_ADD_MEMBERSHIP and IP_DROP_MEMBERSHIP options when you are adding or dropping membership in an IP multicast address.

Availability
Declared In
OpenTransportProviders.h

TLookupBuffer

Defines the format of entries in the buffer passed back in the reply parameter of the OTLookupName function.

struct TLookupBuffer {
   UInt16 fAddressLength;
   UInt16 fNameLength;
   UInt8 fAddressBuffer[1];
};
typedef struct TLookupBuffer TLookupBuffer;
Fields
fAddressLength

Specifies the size of the address specified by the fAddressBuffer field.

fNameLength

Specifies the size of the name that is stored in the buffer following the fAddressBuffer field.

fAddressBuffer

The first byte of the address to which the entity whose name follows (in the buffer) is bound.

Discussion

The TLookupBuffer structure defines the format of entries in the buffer passed back in the reply parameter of the OTLookupName function. When you parse the buffer in which the OTLookupName function places the names it has found, you can cast it as a TLookupBuffer structure.

Availability
Declared In
OpenTransport.h

TLookupReply

Stores information passed back to your application by the OTLookupName function.

struct TLookupReply {
   TNetbuf names;
   UInt32 rspcount;
};
typedef struct TLookupReply TLookupReply;
Fields
names

A TNetbuf structure that specifies the size and location of a buffer into which the OTLookupName function, on return, places the names it has found. You must allocate the buffer into which the replies are stored when the function returns; you must set the names.buf field to point to it; and you must set the names.maxlen field to the size of the buffer.

rspcount

A long specifying, on return, the number of names found.

Discussion

You use the TLookupReply structure to store information passed back to you by the OTLookupName function. The information includes both a pointer to a buffer (containing registered entity names matching the criterion specified with the TLookupRequest structure) and the number of names found.

Availability
Declared In
OpenTransport.h

TLookupRequest

Specifies the entity name to be looked up by the OTLookupName function.

struct TLookupRequest {
   TNetbuf name;
   TNetbuf addr;
   UInt32 maxcnt;
   OTTimeout timeout;
   OTFlags flags;
};
typedef struct TLookupRequest TLookupRequest;
Fields
name

A TNetbuf structure specifying the location and size of a buffer that contains the name to be looked up. You must allocate a buffer that contains the name, set the name.buf field to point to it, and set the name.len field to the length of the name.

addr

A TNetbuf structure describing the address of the node where you expect the names to be stored. You should normally supply 0 for addr.len. This causes the provider to use internal defaults for the starting point of the search. For a protocol family such as AppleTalk, in which every node has access to name and address information, this parameter is meaningless.

Specifying an address has meaning for those protocols that use a dedicated server or other device to store name information. In such a case, the name specified would override the protocol’s default address. To specify an address, you would need to allocate a buffer containing the address, set the addr.buf field to point to it, and set the addr.len field to the length of the address. Consult the documentation supplied with your protocol to determine whether you can or should specify an address.

maxcnt

A long specifying the number of names you expect to be returned. Some protocols allow the use of wildcard characters in specifying a name. As a result, the OTLookupName function might find multiple names matching the specified name pattern. If you expect a specific number of replies for a particular name or do not expect to exceed a specific number, you should specify this number to obtain faster execution. Otherwise, set this field to 0xffff ffff; in this case, the timeout value will control the lookup.

timeout

A long specifying the amount of time, in milliseconds, that should elapse before Open Transport gives up searching for a name. Specify 0 to leave the timeout value up to the underlying naming system.

flags
Discussion

You use the TLookupRequest structure to specify the entity name to be looked up by the OTLookupName function and to set additional values that the mapper provider uses to circumscribe the search.

Availability
Declared In
OpenTransport.h

TNetbuf

Specifies the location and size of a buffer that contains an address, option information, or user data.

struct TNetbuf {
   ByteCount maxlen;
   ByteCount len;
   UInt8 * buf;
};
typedef struct TNetbuf TNetbuf;
Fields
maxlen

The size (in bytes) of the buffer to which the buf field points. You must set the maxlen field before passing a TNetbuf structure to a provider function as an output parameter. Open Transport ignores this field if you pass the TNetbuf structure as an input parameter.

len

The actual length (in bytes) of the information in the buffer to which the buf field points. If you are using the TNetbuf structure as an input parameter, you must set this field.

If you pass the TNetbuf structure as an output parameter, on return the provider function sets this field to the number of bytes the function has actually placed in the buffer referenced by the buf field.

buf

A pointer to a buffer. You must make sure that the buf field points to a valid buffer and that the buffer is large enough to store the information for which it is intended.

Discussion

You use a TNetbuf structure to specify the location and size of a buffer that contains an address, option information, or user data. Provider functions use TNetbuf structures both as input parameters and output parameters. If you use a TNetbuf structure as an input parameter, you specify the location and size of a buffer containing information you want to send. If you use a TNetbuf structure as an output parameter, you specify the location and the maximum size of the buffer used to hold information when the function returns.

You use a TNetbuf structure to describe the location and size of contiguous data. Open Transport allows you to describe noncontiguous data with the OTData structure.

Availability
Declared In
OpenTransport.h

The TOption Structure

Stores information about a single option in a buffer.

struct TOption {
   ByteCount len;
   OTXTILevel level;
   OTXTIName name;
   UInt32 status;
   UInt32 value[1];
};
typedef struct TOption TOption;
Fields
len

The size (in bytes) of the option information, including the header.

level

The protocol for which the option is defined.

name

The name of the option.

status

A status code specifying whether the negotiation has succeeded or failed. Possible values are given by the “Open Transport Flags and Status Codes” enumeration

value

The option value. To have the endpoint select an appropriate value, you can specify the constant T_UNSPEC.

Discussion

The TOption structure stores information about a single option in a buffer. All functions that you use to change or verify option values use a buffer containing TOption structures to store option information. For each option in the buffer, the TOption structure specifies the total length occupied by the option, the protocol level of the option, the option name, the status of a negotiated value, and the value of the option.

You use the TOption structure with the OPT_NEXTHDR macro, the OTCreateOptionString function, the OTNextOption function, and the OTFindOption function.

Availability
Declared In
OpenTransport.h

The TOptionHeader Structure

Stores information about options in a buffer.

struct TOptionHeader {
   ByteCount len;
   OTXTILevel level;
   OTXTIName name;
   UInt32 status;
};
typedef struct TOptionHeader TOptionHeader;
Fields
len

The size (in bytes) of the option information, including the header.

level

The protocol affected.

name

The option name.

status

The status value. Possible values are given by the “Open Transport Flags and Status Codes.”

Availability
Declared In
OpenTransport.h

The Option Management Structure

Manages the req and ret parameters of the OTOptionManagement function

struct TOptMgmt {
   TNetbuf opt;
   OTFlags flags;
};
typedef struct TOptMgmt TOptMgmt;
Fields
opt

A TNetbuf structure describing the buffer containing option information. The opt.maxlen field specifies the maximum size of the buffer. The opt.len field specifies the actual size of the buffer, and the opt.buf field contains the address of the buffer.

On input, as part of the req parameter, the buffer contains TOption structures describing the options to be negotiated or verified, or contains the names of options whose default or current values you are interested in. You must allocate this buffer, place in it the structures describing the options of interest, and set the opt.len field to the size of the buffer.

On output, as part of the ret parameter, the buffer contains the actual values of the options you described in the req parameter. You must allocate a buffer to hold the option information when the function returns and set the opt.maxlen field to the maximum length of this buffer. When the function returns, the opt.len field is set to the actual length of the buffer.

flags

For the req parameter, the flags field indicates the action to be taken as defined by the action flags enumeration (page 570). For the ret parameter, the flags field indicates the overall success or failure of the operation performed by the OTOptionManagement function, as defined by the “Open Transport Flags and Status Codes” enumeration.

Discussion

The option management structure is used for the req and ret parameters of the OTOptionManagement function. The req parameter is used to verify or negotiate option values. The ret parameter returns information about an endpoint’s default, current, or negotiated values.

Availability
Declared In
OpenTransport.h

TOTConfiguratorRef

typedef struct OpaqueTOTConfiguratorRef * TOTConfiguratorRef;
Availability
Declared In
OpenTransportProtocol.h

TPortRecord

struct TPortRecord {
   OTLink fLink;
   char *fPortName;
   char *fModuleName;
   char *fResourceInfo;
   char *fSlotID;
   TPortRecord *fAlias;
   ItemCount fNumChildren;
   OTPortRef *fChildPorts;
   UInt32 fPortFlags;
   UInt32 fInfoFlags;
   UInt32 fCapabilities;
   OTPortRef fRef;
   streamtab *fStreamtab;
   void *fContext;
   void *fExtra;
};
Fields

trace_ids

struct trace_ids {
   short ti_mid;
   short ti_sid;
   char ti_level;
};
typedef struct trace_ids trace_ids;
Fields
ti_mid
ti_sid
ti_level
Availability
Declared In
OpenTransportProtocol.h

TRegisterReply

Stores information returned by the OTRegisterName function.

struct TRegisterReply {
   TNetbuf addr;
   OTNameID nameid;
};
typedef struct TRegisterReply TRegisterReply;
Fields
addr

A TNetbuf structure that specifies the location and size of a buffer containing the actual address of the entity whose name you have just registered. This information is passed back to you when the OTRegisterName function returns. You must allocate a buffer, set the addr.buf field to point to it, and set the addr.maxlen field to the size of the buffer.

nameid

A unique identifier passed to you when the OTRegisterName function returns. You can use this identifier when you call the OTDeleteNameByID function to delete the name.

Availability
Declared In
OpenTransport.h

TRegisterRequest

Specifies the entity name you want to register using the OTRegisterName function and, optionally, to specify its address.

struct TRegisterRequest {
   TNetbuf name;
   TNetbuf addr;
   OTFlags flags;
};
typedef struct TRegisterRequest TRegisterRequest;
Fields
name

A TNetbuf structure that specifies the location and size of a buffer containing the entity name you want to register. You must allocate a buffer that contains the name, set the name.buf field to point to that buffer, and set the name.len field to the length of the buffer.

addr

A TNetbuf structure that specifies the location and size of a buffer containing the address associated with the entity whose name you want to register. You must allocate a buffer that contains the address, set the addr.buf field to point to that buffer, and set the addr.len field to the length of the buffer. The actual address with which the entity is associated is returned in the addr field of the TRegisterReply structure.

You can set the addr.len field to 0, in which case the underlying protocol finds an appropriate address to associate with the newly registered entity name.

flags

A field used to control registration. Normally, this field is set to 0 for default registration behavior. See the documentation for the naming service you are using for more information.

Availability
Declared In
OpenTransport.h

TReply

struct TReply {
   TNetbuf data;
   TNetbuf opt;
   OTSequence sequence;
};
typedef struct TReply TReply;
Fields
data
opt
sequence
Availability
Declared In
OpenTransport.h

TRequest

struct TRequest {
   TNetbuf data;
   TNetbuf opt;
   OTSequence sequence;
};
typedef struct TRequest TRequest;
Fields
data
opt
sequence
Availability
Declared In
OpenTransport.h

TUDErr

In the event of failure of the OTSndUData function, points to information that explains why it failed.function (page 462) has failed.

struct TUDErr {
   TNetbuf addr;
   TNetbuf opt;
   SInt32 error;
};
typedef struct TUDErr TUDErr;
Fields
addr

A TNetbuf structure that contains information about the destination address of the data sent using the OTSndUData function. The OTRcvUData function fills in the buffer referenced by this structure when the function returns. You must allocate a buffer to contain the address, initialize the addr.buf field to point to it, and set the addr.maxlen field to specify its maximum size. If you are not interested in address information, set addr.maxlen to 0.

opt

A TNetbuf structure that contains information about the options associated with the data sent using the OTSndUDatafunction. The OTRcvUDErr function fills in the buffer referenced by this structure when the function returns. If you want to know this information, you must allocate a buffer to contain the option data, initialize the opt.buf field to point to it, and initialize the opt.maxlen field to specify the maximum size of the buffer. If you are not interested in option information, set the opt.maxlen field to 0.

error

On return, this specifies a protocol-dependent error code for the OTSndUData function that failed.

Discussion

In the event of failure of the OTSndUDatafunction, points to information that explains why it failed.You pass this structure as a parameter to the OTRcvUData function.

Availability
Declared In
OpenTransport.h

TUnitData

Describes the data being sent with the OTSndUData function and the data being read with the OTRcvUData function.function (page 467)

struct TUnitData {
   TNetbuf addr;
   TNetbuf opt;
   TNetbuf udata;
};
typedef struct TUnitData TUnitData;
Fields
addr

A TNetbuf structure for address information.

opt

A TNetbuf structure for option information.

udata

A TNetbuf structure for data.

Discussion

You use the TUnitData structure to describe the data being sent with the OTSndUData function and the data being read with the OTRcvUData function; you pass this structure as a parameter to each of these functions. When sending data you must initialize the buf and len fields of all the TNetbuf structures. When receiving data, you must initialize the buf and maxlen fields of all the TNetbuf structures.

Availability
Declared In
OpenTransport.h

TUnitReply

struct TUnitReply {
   TNetbuf opt;
   TNetbuf udata;
   OTSequence sequence;
};
typedef struct TUnitReply TUnitReply;
Fields
opt
udata
sequence
Availability
Declared In
OpenTransport.h

TUnitRequest

struct TUnitRequest {
   TNetbuf addr;
   TNetbuf opt;
   TNetbuf udata;
   OTSequence sequence;
};
typedef struct TUnitRequest TUnitRequest;
Fields
addr
opt
udata
sequence
Discussion

Availability
Declared In
OpenTransport.h

uchar_p

typedef UInt8 uchar_p;
Availability
Declared In
OpenTransport.h

uid_t

typedef UInt32 uid_t;
Availability
Declared In
types.h

uint_t

typedef  uint_t;
Availability
Declared In
OpenTransport.h

ushort_p

typedef UInt16 ushort_p;
Availability
Declared In
OpenTransport.h

Constants

AF_8022

enum {
   AF_8022 = 8200
};
Constants
AF_8022

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

AF_ATALK_FAMILY

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
};
Constants
AF_ATALK_FAMILY

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

AF_ATALK_DDP

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

AF_ATALK_DDPNBP

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

AF_ATALK_NBP

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

AF_ATALK_MNODE

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

AF_DNS

enum {
   AF_DNS = 42
};
Constants
AF_DNS

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

AF_INET

enum {
   AF_INET = 2
};
Constants
AF_INET

AF_ISDN

enum {
   AF_ISDN = 8192
};
Constants
AF_ISDN

ANYMARK

enum {
   ANYMARK = 0x01,
   LASTMARK = 0x02
};
Constants
ANYMARK

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

LASTMARK

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

ATALK_IOC_FULLSELFSEND

enum {
   ATALK_IOC_FULLSELFSEND = ((MIOC_ATALK << 8) | 47),
   ADSP_IOC_FORWARDRESET = ((MIOC_ATALK << 8) | 60)
};
Constants
ATALK_IOC_FULLSELFSEND

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

ADSP_IOC_FORWARDRESET

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

ATK_DDP

enum {
   ATK_DDP = 'DDP ',
   ATK_AARP = 'AARP',
   ATK_ATP = 'ATP ',
   ATK_ADSP = 'ADSP',
   ATK_ASP = 'ASP ',
   ATK_PAP = 'PAP ',
   ATK_NBP = 'NBP ',
   ATK_ZIP = 'ZIP '
};
Constants
ATK_DDP

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

ATK_AARP

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

ATK_ATP

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

ATK_ADSP

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

ATK_ASP

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

ATK_PAP

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

ATK_NBP

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

ATK_ZIP

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

BPRI_LO

enum {
   BPRI_LO = 1,
   BPRI_MED = 2,
   BPRI_HI = 3
};
Constants
BPRI_LO

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

BPRI_MED

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

BPRI_HI

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

CE_CONT

enum {
   CE_CONT = 0,
   CE_NOTE = 0,
   CE_WARN = 1,
   CE_PANIC = 2
};
Constants
CE_CONT
CE_NOTE
CE_WARN
CE_PANIC

CLONEOPEN

enum {
   CLONEOPEN = 0x02,
   MODOPEN = 0x01,
   OPENFAIL = -1
};
Constants
CLONEOPEN

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

MODOPEN

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

OPENFAIL

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

COM_ISDN

enum {
   COM_ISDN = 'ISDN'
};
Constants
COM_ISDN

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

COM_PPP

enum {
   COM_PPP = 'PPPC'
};
Constants
COM_PPP

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

COM_SERIAL

enum {
   COM_SERIAL = 'SERL'
};
Constants
COM_SERIAL

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

DDP_OPT_CHECKSUM

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
};
Constants
DDP_OPT_CHECKSUM

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

DDP_OPT_SRCADDR

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

ATP_OPT_REPLYCNT

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

ATP_OPT_DATALEN

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

ATP_OPT_RELTIMER

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

ATP_OPT_TRANID

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

PAP_OPT_OPENRETRY

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

DDP_OPT_HOPCOUNT

enum {
   DDP_OPT_HOPCOUNT = 0x2100
};
Constants
DDP_OPT_HOPCOUNT

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProviders.h.

DL_ACCESS

enum {
   DL_ACCESS = 0x02,
   DL_BADADDR = 0x01,
   DL_BADCORR = 0x05,
   DL_BADDATA = 0x06,
   DL_BADPPA = 0x08,
   DL_BADPRIM = 0x09,
   DL_BADQOSPARAM = 0x0A,
   DL_BADQOSTYPE = 0x0B,
   DL_BADSAP = 0x00,
   DL_BADTOKEN = 0x0C,
   DL_BOUND = 0x0D,
   DL_INITFAILED = 0x0E,
   DL_NOADDR = 0x0F,
   DL_NOTINIT = 0x10,
   DL_OUTSTATE = 0x03,
   DL_SYSERR = 0x04,
   DL_UNSUPPORTED = 0x07,
   DL_UNDELIVERABLE = 0x11,
   DL_NOTSUPPORTED = 0x12,
   DL_TOOMANY = 0x13,
   DL_NOTENAB = 0x14,
   DL_BUSY = 0x15,
   DL_NOAUTO = 0x16,
   DL_NOXIDAUTO = 0x17,
   DL_NOTESTAUTO = 0x18,
   DL_XIDAUTO = 0x19,
   DL_TESTAUTO = 0x1A,
   DL_PENDING = 0x1B
};
Constants
DL_ACCESS

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_BADADDR

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_BADCORR

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_BADDATA

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_BADPPA

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_BADPRIM

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_BADQOSPARAM

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_BADQOSTYPE

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_BADSAP

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_BADTOKEN

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_BOUND

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_INITFAILED

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_NOADDR

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_NOTINIT

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_OUTSTATE

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_SYSERR

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_UNSUPPORTED

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_UNDELIVERABLE

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_NOTSUPPORTED

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_TOOMANY

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_NOTENAB

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_BUSY

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_NOAUTO

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_NOXIDAUTO

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_NOTESTAUTO

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_XIDAUTO

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_TESTAUTO

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_PENDING

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_AUTO_XID

enum {
   DL_AUTO_XID = 0x01,
   DL_AUTO_TEST = 0x02
};
Constants
DL_AUTO_XID

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_AUTO_TEST

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_CMD_MASK

enum {
   DL_CMD_MASK = 0x0F,
   DL_CMD_OK = 0x00,
   DL_CMD_RS = 0x01,
   DL_CMD_UE = 0x05,
   DL_CMD_PE = 0x06,
   DL_CMD_IP = 0x07,
   DL_CMD_UN = 0x09,
   DL_CMD_IT = 0x0F,
   DL_RSP_MASK = 0xF0,
   DL_RSP_OK = 0x00,
   DL_RSP_RS = 0x10,
   DL_RSP_NE = 0x30,
   DL_RSP_NR = 0x40,
   DL_RSP_UE = 0x50,
   DL_RSP_IP = 0x70,
   DL_RSP_UN = 0x90,
   DL_RSP_IT = 0xF0
};
Constants
DL_CMD_MASK

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL_CMD_OK

Available in Mac OS X v10.0 and later.

Declared in OpenTransportProtocol.h.

DL