mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-22 22:27:05 +00:00
5242 lines
177 KiB
C++
5242 lines
177 KiB
C++
/*
|
|
File: OpenTransportProtocol.h
|
|
|
|
Contains: Definitions likely to be used by low-level protocol stack implementation.
|
|
|
|
Version: QuickTime 7.3
|
|
|
|
Copyright: (c) 2007 (c) 1993-2001 by Apple Computer, Inc. and Mentat Inc., all rights reserved.
|
|
|
|
Bugs?: For bug reports, consult the following page on
|
|
the World Wide Web:
|
|
|
|
http://developer.apple.com/bugreporter/
|
|
|
|
*/
|
|
#ifndef __OPENTRANSPORTPROTOCOL__
|
|
#define __OPENTRANSPORTPROTOCOL__
|
|
|
|
#ifndef __CONDITIONALMACROS__
|
|
#include <ConditionalMacros.h>
|
|
#endif
|
|
|
|
|
|
#if CALL_NOT_IN_CARBON
|
|
#ifndef __FILES__
|
|
#include <Files.h>
|
|
#endif
|
|
|
|
#ifndef __CODEFRAGMENTS__
|
|
#include <CodeFragments.h>
|
|
#endif
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
#ifndef __OPENTRANSPORT__
|
|
#include <OpenTransport.h>
|
|
#endif
|
|
|
|
|
|
#ifdef __cplusplus
|
|
#include <stddef.h>
|
|
#endif
|
|
|
|
|
|
#if PRAGMA_ONCE
|
|
#pragma once
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#if PRAGMA_IMPORT
|
|
#pragma import on
|
|
#endif
|
|
|
|
#if PRAGMA_STRUCT_ALIGN
|
|
#pragma options align=mac68k
|
|
#elif PRAGMA_STRUCT_PACKPUSH
|
|
#pragma pack(push, 2)
|
|
#elif PRAGMA_STRUCT_PACK
|
|
#pragma pack(2)
|
|
#endif
|
|
|
|
#if defined(__MWERKS__) && TARGET_CPU_68K
|
|
#pragma push
|
|
#pragma pointers_in_D0
|
|
#endif
|
|
|
|
/* ***** Setup Default Compiler Variables ******/
|
|
|
|
/*
|
|
OTKERNEL is used to indicate whether the code is being built
|
|
for the kernel environment. It defaults to 0. If you include
|
|
"OpenTransportKernel.h" before including this file,
|
|
it will be 1 and you will only be able to see stuff available
|
|
to kernel code.
|
|
As we've included "OpenTransport.h" and it defaults this variable
|
|
to 0 if it's not already been defined, it should always be defined
|
|
by the time we get here. So we just assert that. Assertions in
|
|
header files! Cool (-:
|
|
*/
|
|
|
|
#ifndef OTKERNEL
|
|
#error OpenTransportProtocol.h expects OpenTransport.h to set up OTKERNEL.
|
|
#endif /* !defined(OTKERNEL) */
|
|
|
|
/* ***** Shared Client Memory ******/
|
|
#if !OTKERNEL
|
|
/*
|
|
These allocators allocate memory in the shared client pool,
|
|
which is shared between all clients and is not disposed when
|
|
a particular client goes away. See DTS Technote ooo
|
|
"Understanding Open Transport Memory Management" for details.
|
|
*/
|
|
#if CALL_NOT_IN_CARBON
|
|
/*
|
|
* OTAllocSharedClientMem()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void * )
|
|
OTAllocSharedClientMem(OTByteCount size);
|
|
|
|
|
|
/*
|
|
* OTFreeSharedClientMem()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTFreeSharedClientMem(void * mem);
|
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
#endif /* !OTKERNEL */
|
|
|
|
/* ***** UNIX Types ******/
|
|
#if CALL_NOT_IN_CARBON
|
|
/*
|
|
On UNIX, uid_t and gid_t are defined to be big enough
|
|
to hold a user ID and group ID respectively. As Mac OS
|
|
has no such concepts, we just define them as UInt32 place
|
|
holders.
|
|
*/
|
|
typedef UInt32 uid_t;
|
|
typedef UInt32 gid_t;
|
|
/* Similarly, dev_t is a UNIX type for denoting a device number.*/
|
|
typedef UInt32 dev_t;
|
|
/* ***** From the Mentat "strstat.h" ******/
|
|
|
|
/* module statistics structure */
|
|
struct module_stat {
|
|
long ms_pcnt; /* count of calls to put proc */
|
|
long ms_scnt; /* count of calls to service proc */
|
|
long ms_ocnt; /* count of calls to open proc */
|
|
long ms_ccnt; /* count of calls to close proc */
|
|
long ms_acnt; /* count of calls to admin proc */
|
|
char * ms_xptr; /* pointer to private statistics */
|
|
short ms_xsize; /* length of private statistics buffer */
|
|
};
|
|
typedef struct module_stat module_stat;
|
|
/* ***** From the Mentat "cred.h" ******/
|
|
|
|
struct cred {
|
|
UInt16 cr_ref; /* reference count on processes using cred structures */
|
|
UInt16 cr_ngroups; /* number of groups in cr_groups */
|
|
uid_t cr_uid; /* effective user id */
|
|
gid_t cr_gid; /* effective group id */
|
|
uid_t cr_ruid; /* real user id */
|
|
gid_t cr_rgid; /* real group id */
|
|
uid_t cr_suid; /* user id saved by exec */
|
|
gid_t cr_sgid; /* group id saved by exec */
|
|
gid_t cr_groups[1]; /* supplementary groups list */
|
|
};
|
|
typedef struct cred cred;
|
|
typedef cred cred_t;
|
|
/* Free return structure for esballoc */
|
|
typedef CALLBACK_API_C( void , FreeFuncType )(char * arg);
|
|
struct free_rtn {
|
|
FreeFuncType free_func; /* Routine to call to free buffer */
|
|
char * free_arg; /* Parameter to free_func */
|
|
};
|
|
typedef struct free_rtn free_rtn;
|
|
typedef free_rtn frtn_t;
|
|
/* data descriptor */
|
|
typedef struct datab datab;
|
|
union datab_db_f {
|
|
datab * freep;
|
|
free_rtn * frtnp;
|
|
};
|
|
typedef union datab_db_f datab_db_f;
|
|
struct datab {
|
|
datab_db_f db_f;
|
|
unsigned char * db_base; /* first byte of buffer */
|
|
unsigned char * db_lim; /* last byte+1 of buffer */
|
|
unsigned char db_ref; /* count of messages pointing to block*/
|
|
unsigned char db_type; /* message type */
|
|
unsigned char db_iswhat; /* message status */
|
|
unsigned char db_filler2; /* for spacing */
|
|
UInt32 db_size; /* used internally */
|
|
unsigned char * db_msgaddr; /* used internally */
|
|
long db_filler;
|
|
};
|
|
|
|
|
|
typedef datab dblk_t;
|
|
#define db_freep db_f.freep
|
|
#define db_frtnp db_f.frtnp
|
|
|
|
/* message block */
|
|
struct msgb {
|
|
struct msgb * b_next; /* next message on queue */
|
|
struct msgb * b_prev; /* previous message on queue */
|
|
struct msgb * b_cont; /* next message block of message */
|
|
unsigned char * b_rptr; /* first unread data byte in buffer */
|
|
unsigned char * b_wptr; /* first unwritten data byte */
|
|
datab * b_datap; /* data block */
|
|
unsigned char b_band; /* message priority */
|
|
unsigned char b_pad1;
|
|
unsigned short b_flag;
|
|
#ifdef MSGB_XTRA
|
|
|
|
MSGB_XTRA
|
|
|
|
#endif
|
|
|
|
};
|
|
typedef struct msgb msgb;
|
|
typedef msgb mblk_t;
|
|
/* mblk flags */
|
|
enum {
|
|
MSGMARK = 0x01, /* last byte of message is tagged */
|
|
MSGNOLOOP = 0x02, /* don't pass message to write-side of stream */
|
|
MSGDELIM = 0x04, /* message is delimited */
|
|
MSGNOGET = 0x08
|
|
};
|
|
|
|
/* STREAMS environments are expected to define these constants in a public header file.*/
|
|
|
|
enum {
|
|
STRCTLSZ = 256, /* Maximum Control buffer size for messages */
|
|
STRMSGSZ = 8192 /* Maximum # data bytes for messages */
|
|
};
|
|
|
|
/* Message types */
|
|
enum {
|
|
QNORM = 0,
|
|
M_DATA = 0, /* Ordinary data */
|
|
M_PROTO = 1, /* Internal control info and data */
|
|
M_BREAK = 0x08, /* Request a driver to send a break */
|
|
M_PASSFP = 0x09, /* Used to pass a file pointer */
|
|
M_SIG = 0x0B, /* Requests a signal to be sent */
|
|
M_DELAY = 0x0C, /* Request a real-time delay */
|
|
M_CTL = 0x0D, /* For inter-module communication */
|
|
M_IOCTL = 0x0E, /* Used internally for I_STR requests */
|
|
M_SETOPTS = 0x10, /* Alters characteristics of Stream head */
|
|
M_RSE = 0x11 /* Reserved for internal use */
|
|
};
|
|
|
|
/* MPS private type */
|
|
enum {
|
|
M_MI = 0x40,
|
|
M_MI_READ_RESET = 1,
|
|
M_MI_READ_SEEK = 2,
|
|
M_MI_READ_END = 4
|
|
};
|
|
|
|
/* Priority messages types */
|
|
enum {
|
|
QPCTL = 0x80,
|
|
M_IOCACK = 0x81, /* Positive ack of previous M_IOCTL */
|
|
M_IOCNAK = 0x82, /* Previous M_IOCTL failed */
|
|
M_PCPROTO = 0x83, /* Same as M_PROTO except for priority */
|
|
M_PCSIG = 0x84, /* Priority signal */
|
|
M_FLUSH = 0x86, /* Requests modules to flush queues */
|
|
M_STOP = 0x87, /* Request drivers to stop output */
|
|
M_START = 0x88, /* Request drivers to start output */
|
|
M_HANGUP = 0x89, /* Driver can no longer produce data */
|
|
M_ERROR = 0x8A, /* Reports downstream error condition */
|
|
M_READ = 0x8B, /* Reports client read at Stream head */
|
|
M_COPYIN = 0x8C, /* Requests the Stream to copy data in for a module */
|
|
M_COPYOUT = 0x8D, /* Requests the Stream to copy data out for a module */
|
|
M_IOCDATA = 0x8E, /* Status from M_COPYIN/M_COPYOUT message */
|
|
M_PCRSE = 0x90, /* Reserved for internal use */
|
|
M_STOPI = 0x91, /* Request drivers to stop input */
|
|
M_STARTI = 0x92, /* Request drivers to start input */
|
|
M_HPDATA = 0x93 /* MPS-private type; high priority data */
|
|
};
|
|
|
|
/* Defines for flush messages */
|
|
enum {
|
|
FLUSHALL = 1,
|
|
FLUSHDATA = 0
|
|
};
|
|
|
|
|
|
enum {
|
|
NOERROR = -1 /* used in M_ERROR messages */
|
|
};
|
|
|
|
typedef struct sth_s sth_s;
|
|
typedef struct sqh_s sqh_s;
|
|
typedef struct q_xtra q_xtra;
|
|
#if OTKERNEL
|
|
/*
|
|
module_info is aligned differently on 68K than
|
|
on PowerPC. Yucky. I can't defined a conditionalised
|
|
pad field because a) you can't conditionalise specific
|
|
fields in the interface definition language used to
|
|
create Universal Interfaces, and b) lots of code
|
|
assigns C structured constants to global variables
|
|
of this type, and these assignments break if you
|
|
add an extra field to the type. Instead, I
|
|
set the alignment appropriately before defining the
|
|
structure. The problem with doing that is that
|
|
the interface definition language doesn't allow
|
|
my to set the alignment in the middle of a file,
|
|
so I have to do this via "pass throughs". This
|
|
works fine for the well known languages (C, Pascal),
|
|
but may cause problems for other languages (Java,
|
|
Asm).
|
|
*/
|
|
#if TARGET_CPU_PPC
|
|
#pragma options align=power
|
|
#endif
|
|
struct module_info {
|
|
unsigned short mi_idnum; /* module ID number */
|
|
char * mi_idname; /* module name */
|
|
long mi_minpsz; /* min pkt size, for developer use */
|
|
long mi_maxpsz; /* max pkt size, for developer use */
|
|
unsigned long mi_hiwat; /* hi-water mark, for flow control */
|
|
unsigned long mi_lowat; /* lo-water mark, for flow control */
|
|
};
|
|
typedef struct module_info module_info;
|
|
typedef module_info * module_infoPtr;
|
|
#if TARGET_CPU_PPC
|
|
#pragma options align=reset
|
|
#endif
|
|
|
|
|
|
typedef struct queue queue;
|
|
typedef CALLBACK_API_C( OTInt32 , admin_t )(void);
|
|
typedef CALLBACK_API_C( void , bufcall_t )(long size);
|
|
typedef CALLBACK_API_C( void , bufcallp_t )(long size);
|
|
typedef CALLBACK_API_C( OTInt32 , closep_t )(queue *q, OTInt32 foo, cred_t *cred);
|
|
typedef CALLBACK_API_C( OTInt32 , old_closep_t )(queue * q);
|
|
typedef CALLBACK_API_C( OTInt32 , openp_t )(queue *q, dev_t *dev, OTInt32 foo, OTInt32 bar, cred_t *cred);
|
|
typedef CALLBACK_API_C( OTInt32 , openOld_t )(queue *q, dev_t dev, OTInt32 foo, OTInt32 bar);
|
|
typedef CALLBACK_API_C( OTInt32 , old_openp_t )(queue *q, dev_t dev, OTInt32 foo, OTInt32 bar);
|
|
typedef CALLBACK_API_C( OTInt32 , closeOld_t )(queue * q);
|
|
typedef CALLBACK_API_C( OTInt32 , putp_t )(queue *q, msgb *mp);
|
|
typedef CALLBACK_API_C( OTInt32 , srvp_t )(queue * q);
|
|
struct qinit {
|
|
putp_t qi_putp; /* put procedure */
|
|
srvp_t qi_srvp; /* service procedure */
|
|
openp_t qi_qopen; /* called on each open or a push */
|
|
closep_t qi_qclose; /* called on last close or a pop */
|
|
admin_t qi_qadmin; /* reserved for future use */
|
|
module_info * qi_minfo; /* information structure */
|
|
module_stat * qi_mstat; /* statistics structure - optional */
|
|
};
|
|
typedef struct qinit qinit;
|
|
/* defines module or driver */
|
|
struct streamtab {
|
|
qinit * st_rdinit; /* defines read QUEUE */
|
|
qinit * st_wrinit; /* defines write QUEUE */
|
|
qinit * st_muxrinit; /* for multiplexing drivers only */
|
|
qinit * st_muxwinit; /* ditto */
|
|
};
|
|
typedef struct streamtab streamtab;
|
|
struct qband {
|
|
struct qband * qb_next; /* next band for this queue */
|
|
unsigned long qb_count; /* weighted count of characters in this band */
|
|
msgb * qb_first; /* head of message queue */
|
|
msgb * qb_last; /* tail of message queue */
|
|
unsigned long qb_hiwat; /* high water mark */
|
|
unsigned long qb_lowat; /* low water mark */
|
|
unsigned short qb_flag; /* ooo.state */
|
|
short qb_pad1; /* ooo reserved */
|
|
};
|
|
typedef struct qband qband;
|
|
typedef qband qband_t;
|
|
union queue_q_u {
|
|
queue * q_u_link; /* link to scheduling queue */
|
|
sqh_s * q_u_sqh_parent;
|
|
};
|
|
typedef union queue_q_u queue_q_u;
|
|
struct queue {
|
|
qinit * q_qinfo; /* procedures and limits for queue */
|
|
msgb * q_first; /* head of message queue */
|
|
msgb * q_last; /* tail of message queue */
|
|
struct queue * q_next; /* next queue in Stream */
|
|
queue_q_u q_u;
|
|
char * q_ptr; /* to private data structure */
|
|
unsigned long q_count; /* weighted count of characters on q */
|
|
long q_minpsz; /* min packet size accepted */
|
|
long q_maxpsz; /* max packet size accepted */
|
|
unsigned long q_hiwat; /* high water mark, for flow control */
|
|
unsigned long q_lowat; /* low water mark */
|
|
qband * q_bandp; /* band information */
|
|
unsigned short q_flag; /* ooo queue state */
|
|
unsigned char q_nband; /* ooo number of bands */
|
|
unsigned char q_pad1[1]; /* ooo reserved */
|
|
q_xtra * q_osx; /* Pointer to OS-dependent extra stuff */
|
|
struct queue * q_ffcp; /* Forward flow control pointer */
|
|
struct queue * q_bfcp; /* Backward flow control pointer */
|
|
};
|
|
|
|
|
|
typedef queue * queuePtr;
|
|
typedef queue queue_t;
|
|
#define q_link q_u.q_u_link
|
|
#define q_sqh_parent q_u.q_u_sqh_parent
|
|
|
|
/* queue_t flag defines */
|
|
enum {
|
|
QREADR = 0x01, /* This queue is a read queue */
|
|
QNOENB = 0x02, /* Don't enable in putq */
|
|
QFULL = 0x04, /* The queue is full */
|
|
QWANTR = 0x08, /* The queue should be scheduled in the next putq */
|
|
QWANTW = 0x10, /* The stream should be back enabled when this queue drains */
|
|
QUSE = 0x20, /* The queue is allocated and ready for use */
|
|
QENAB = 0x40, /* The queue is scheduled (on the run queue) */
|
|
QBACK = 0x80, /* The queue has been back enabled */
|
|
QOLD = 0x0100, /* Module supports old style opens and closes */
|
|
QHLIST = 0x0200, /* The Stream head is doing something with this queue (Not supported by MPS) */
|
|
QWELDED = 0x0400, /* Mentat flag for welded queues */
|
|
QUNWELDING = 0x0800, /* Queue is scheduled to be unwelded */
|
|
QPROTECTED = 0x1000, /* Mentat flag for unsafe q access */
|
|
QEXCOPENCLOSE = 0x2000 /* Queue wants exclusive open/close calls */
|
|
};
|
|
|
|
/* qband_t flag defines */
|
|
enum {
|
|
QB_FULL = 0x01, /* The band is full */
|
|
QB_WANTW = 0x02, /* The stream should be back enabled when this band/queue drains */
|
|
QB_BACK = 0x04 /* The queue has been back enabled */
|
|
};
|
|
|
|
#else
|
|
/*
|
|
Client code views a queue_t as a simple cookie.
|
|
The real definition lives above and is only available
|
|
to kernel code.
|
|
*/
|
|
typedef SInt32 queue_t;
|
|
#endif /* OTKERNEL */
|
|
|
|
/* structure contained in M_COPYIN/M_COPYOUT messages */
|
|
typedef char * caddr_t;
|
|
struct copyreq {
|
|
SInt32 cq_cmd; /* ioctl command (from ioc_cmd) */
|
|
cred * cq_cr; /* pointer to full credentials */
|
|
UInt32 cq_id; /* ioctl id (from ioc_id) */
|
|
caddr_t cq_addr; /* address to copy data to/from */
|
|
UInt32 cq_size; /* number of bytes to copy */
|
|
SInt32 cq_flag; /* state */
|
|
mblk_t * cq_private; /* private state information */
|
|
long cq_filler[4];
|
|
};
|
|
typedef struct copyreq copyreq;
|
|
#define cq_uid cq_cr->cr_uid
|
|
#define cq_gid cq_cr->cr_gid
|
|
|
|
|
|
/* copyreq defines */
|
|
enum {
|
|
STRCANON = 0x01, /* b_cont data block contains canonical format specifier */
|
|
RECOPY = 0x02 /* perform I_STR copyin again this time using canonical format specifier */
|
|
};
|
|
|
|
/* structure contained in M_IOCDATA message block */
|
|
struct copyresp {
|
|
SInt32 cp_cmd; /* ioctl command (from ioc_cmd) */
|
|
cred * cp_cr; /* pointer to full credentials */
|
|
UInt32 cp_id; /* ioctl id (from ioc_id) */
|
|
caddr_t cp_rval; /* status of request; 0 for success; error value for failure */
|
|
UInt32 cp_pad1;
|
|
SInt32 cp_pad2;
|
|
mblk_t * cp_private; /* private state information */
|
|
long cp_filler[4];
|
|
};
|
|
typedef struct copyresp copyresp;
|
|
#define cp_uid cp_cr->cr_uid
|
|
#define cp_gid cp_cr->cr_gid
|
|
|
|
/* structure contained in an M_IOCTL message block */
|
|
struct iocblk {
|
|
SInt32 ioc_cmd; /* ioctl command type */
|
|
cred * ioc_cr; /* pointer to full credentials */
|
|
UInt32 ioc_id; /* ioctl id */
|
|
UInt32 ioc_count; /* count of bytes in data field */
|
|
SInt32 ioc_error; /* error code */
|
|
SInt32 ioc_rval; /* return value */
|
|
long ioc_filler[4];
|
|
};
|
|
typedef struct iocblk iocblk;
|
|
#define ioc_uid ioc_cr->cr_uid
|
|
#define ioc_gid ioc_cr->cr_gid
|
|
|
|
|
|
|
|
enum {
|
|
TRANSPARENT = (unsigned long)0xFFFFFFFF
|
|
};
|
|
|
|
/* Used in M_IOCTL mblks to muxes (ioc_cmd I_LINK) */
|
|
struct linkblk {
|
|
queue_t * l_qtop; /* lowest level write queue of upper stream */
|
|
queue_t * l_qbot; /* highest level write queue of lower stream */
|
|
SInt32 l_index; /* system-unique index for lower stream */
|
|
long l_pad[5];
|
|
};
|
|
typedef struct linkblk linkblk;
|
|
/* structure contained in an M_PASSFP message block */
|
|
struct strpfp {
|
|
unsigned long pass_file_cookie; /* file 'pointer' */
|
|
unsigned short pass_uid; /* user id of sending stream */
|
|
unsigned short pass_gid;
|
|
sth_s * pass_sth; /* Stream head pointer of passed stream */
|
|
};
|
|
typedef struct strpfp strpfp;
|
|
/* structure contained in an M_SETOPTS message block */
|
|
struct stroptions {
|
|
unsigned long so_flags; /* options to set */
|
|
short so_readopt; /* read option */
|
|
unsigned short so_wroff; /* write offset */
|
|
long so_minpsz; /* minimum read packet size */
|
|
long so_maxpsz; /* maximum read packet size */
|
|
unsigned long so_hiwat; /* read queue high-water mark */
|
|
unsigned long so_lowat; /* read queue low-water mark */
|
|
unsigned char so_band; /* band for water marks */
|
|
unsigned char so_filler[3]; /* added for alignment */
|
|
unsigned long so_poll_set; /* poll events to set */
|
|
unsigned long so_poll_clr; /* poll events to clear */
|
|
};
|
|
typedef struct stroptions stroptions;
|
|
/* definitions for so_flags field */
|
|
enum {
|
|
SO_ALL = 0x7FFF, /* Update all options */
|
|
SO_READOPT = 0x0001, /* Set the read mode */
|
|
SO_WROFF = 0x0002, /* Insert an offset in write M_DATA mblks */
|
|
SO_MINPSZ = 0x0004, /* Change the min packet size on sth rq */
|
|
SO_MAXPSZ = 0x0008, /* Change the max packet size on sth rq */
|
|
SO_HIWAT = 0x0010, /* Change the high water mark on sth rq */
|
|
SO_LOWAT = 0x0020, /* Change the low water mark */
|
|
SO_MREADON = 0x0040, /* Request M_READ messages */
|
|
SO_MREADOFF = 0x0080, /* Don't gen M_READ messages */
|
|
SO_NDELON = 0x0100, /* old TTY semantics for O_NDELAY reads and writes */
|
|
SO_NDELOFF = 0x0200, /* STREAMS semantics for O_NDELAY reads and writes */
|
|
SO_ISTTY = 0x0400, /* Become a controlling tty */
|
|
SO_ISNTTY = 0x0800, /* No longer a controlling tty */
|
|
SO_TOSTOP = 0x1000, /* Stop on background writes */
|
|
SO_TONSTOP = 0x2000, /* Don't stop on background writes */
|
|
SO_BAND = 0x4000, /* Water marks are for a band */
|
|
SO_POLL_SET = 0x8000, /* Set events to poll */
|
|
SO_POLL_CLR = 0x00010000 /* Clear events to poll */
|
|
};
|
|
|
|
/* Buffer Allocation Priority */
|
|
enum {
|
|
BPRI_LO = 1,
|
|
BPRI_MED = 2,
|
|
BPRI_HI = 3
|
|
};
|
|
|
|
enum {
|
|
INFPSZ = -1
|
|
};
|
|
|
|
|
|
/** Test whether message is a data message */
|
|
#define datamsg(type) ((type) == M_DATA || (type) == M_PROTO || (type) == M_PCPROTO || (type) == M_DELAY)
|
|
|
|
enum {
|
|
CLONEOPEN = 0x02,
|
|
MODOPEN = 0x01,
|
|
OPENFAIL = -1
|
|
};
|
|
|
|
|
|
/* Enumeration values for strqget and strqset */
|
|
typedef SInt32 qfields;
|
|
enum {
|
|
QHIWAT = 0,
|
|
QLOWAT = 1,
|
|
QMAXPSZ = 2,
|
|
QMINPSZ = 3,
|
|
QCOUNT = 4,
|
|
QFIRST = 5,
|
|
QLAST = 6,
|
|
QFLAG = 7,
|
|
QBAD = 8
|
|
};
|
|
|
|
|
|
typedef qfields qfields_t;
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
/* ***** From the Mentat "stropts.h" ******/
|
|
|
|
|
|
enum {
|
|
I_NREAD = ((MIOC_STREAMIO << 8) | 1), /* return the number of bytes in 1st msg */
|
|
I_PUSH = ((MIOC_STREAMIO << 8) | 2), /* push module just below stream head */
|
|
I_POP = ((MIOC_STREAMIO << 8) | 3), /* pop module below stream head */
|
|
I_LOOK = ((MIOC_STREAMIO << 8) | 4), /* retrieve name of first stream module */
|
|
I_FLUSH = ((MIOC_STREAMIO << 8) | 5), /* flush all input and/or output queues */
|
|
I_SRDOPT = ((MIOC_STREAMIO << 8) | 6), /* set the read mode */
|
|
I_GRDOPT = ((MIOC_STREAMIO << 8) | 7), /* get the current read mode */
|
|
I_STR = ((MIOC_STREAMIO << 8) | 8), /* create an internal ioctl message */
|
|
I_SETSIG = ((MIOC_STREAMIO << 8) | 9), /* request SIGPOLL signal on events */
|
|
I_GETSIG = ((MIOC_STREAMIO << 8) | 10), /* query the registered events */
|
|
I_FIND = ((MIOC_STREAMIO << 8) | 11), /* check for module in stream */
|
|
I_LINK = ((MIOC_STREAMIO << 8) | 12), /* connect stream under mux fd */
|
|
I_UNLINK = ((MIOC_STREAMIO << 8) | 13), /* disconnect two streams */
|
|
I_PEEK = ((MIOC_STREAMIO << 8) | 15), /* peek at data on read queue */
|
|
I_FDINSERT = ((MIOC_STREAMIO << 8) | 16), /* create a message and send downstream */
|
|
I_SENDFD = ((MIOC_STREAMIO << 8) | 17), /* send an fd to a connected pipe stream */
|
|
I_RECVFD = ((MIOC_STREAMIO << 8) | 18), /* retrieve a file descriptor */
|
|
I_FLUSHBAND = ((MIOC_STREAMIO << 8) | 19), /* flush a particular input and/or output band */
|
|
I_SWROPT = ((MIOC_STREAMIO << 8) | 20), /* set the write mode */
|
|
I_GWROPT = ((MIOC_STREAMIO << 8) | 21), /* get the current write mode */
|
|
I_LIST = ((MIOC_STREAMIO << 8) | 22), /* get a list of all modules on a stream */
|
|
I_ATMARK = ((MIOC_STREAMIO << 8) | 23), /* check to see if the next message is "marked" */
|
|
I_CKBAND = ((MIOC_STREAMIO << 8) | 24), /* check for a message of a particular band */
|
|
I_GETBAND = ((MIOC_STREAMIO << 8) | 25), /* get the band of the next message to be read */
|
|
I_CANPUT = ((MIOC_STREAMIO << 8) | 26), /* check to see if a message may be passed on a stream */
|
|
I_SETCLTIME = ((MIOC_STREAMIO << 8) | 27), /* set the close timeout wait */
|
|
I_GETCLTIME = ((MIOC_STREAMIO << 8) | 28), /* get the current close timeout wait */
|
|
I_PLINK = ((MIOC_STREAMIO << 8) | 29), /* permanently connect a stream under a mux */
|
|
I_PUNLINK = ((MIOC_STREAMIO << 8) | 30), /* disconnect a permanent link */
|
|
I_GETMSG = ((MIOC_STREAMIO << 8) | 40), /* getmsg() system call */
|
|
I_PUTMSG = ((MIOC_STREAMIO << 8) | 41), /* putmsg() system call */
|
|
I_POLL = ((MIOC_STREAMIO << 8) | 42), /* poll() system call */
|
|
I_SETDELAY = ((MIOC_STREAMIO << 8) | 43), /* set blocking status */
|
|
I_GETDELAY = ((MIOC_STREAMIO << 8) | 44), /* get blocking status */
|
|
I_RUN_QUEUES = ((MIOC_STREAMIO << 8) | 45), /* sacrifice for the greater good */
|
|
I_GETPMSG = ((MIOC_STREAMIO << 8) | 46), /* getpmsg() system call */
|
|
I_PUTPMSG = ((MIOC_STREAMIO << 8) | 47), /* putpmsg() system call */
|
|
I_AUTOPUSH = ((MIOC_STREAMIO << 8) | 48), /* for systems that cannot do the autopush in open */
|
|
I_PIPE = ((MIOC_STREAMIO << 8) | 49), /* for pipe library call */
|
|
I_HEAP_REPORT = ((MIOC_STREAMIO << 8) | 50), /* get heap statistics */
|
|
I_FIFO = ((MIOC_STREAMIO << 8) | 51) /* for fifo library call */
|
|
};
|
|
|
|
/* priority message request on putmsg() or strpeek */
|
|
enum {
|
|
RS_HIPRI = 0x01
|
|
};
|
|
|
|
/* flags for getpmsg and putpmsg */
|
|
enum {
|
|
MSG_HIPRI = 0x01,
|
|
MSG_BAND = 0x02, /* Retrieve a message from a particular band */
|
|
MSG_ANY = 0x04 /* Retrieve a message from any band */
|
|
};
|
|
|
|
/* return values from getmsg(), 0 indicates all ok */
|
|
enum {
|
|
MORECTL = 0x01, /* more control info available */
|
|
MOREDATA = 0x02 /* more data available */
|
|
};
|
|
|
|
|
|
enum {
|
|
FMNAMESZ = 31 /* maximum length of a module or device name */
|
|
};
|
|
|
|
|
|
/* Infinite poll wait time */
|
|
enum {
|
|
INFTIM = (unsigned long)0xFFFFFFFF
|
|
};
|
|
|
|
/* flush requests */
|
|
enum {
|
|
FLUSHR = 0x01, /* Flush the read queue */
|
|
FLUSHW = 0x02, /* Flush the write queue */
|
|
FLUSHRW = (FLUSHW | FLUSHR) /* Flush both */
|
|
};
|
|
|
|
enum {
|
|
FLUSHBAND = 0x40 /* Flush a particular band */
|
|
};
|
|
|
|
/* I_FLUSHBAND */
|
|
struct bandinfo {
|
|
unsigned char bi_pri; /* Band to flush */
|
|
char pad1;
|
|
SInt32 bi_flag; /* One of the above flush requests */
|
|
};
|
|
typedef struct bandinfo bandinfo;
|
|
/* flags for I_ATMARK */
|
|
enum {
|
|
ANYMARK = 0x01, /* Check if message is marked */
|
|
LASTMARK = 0x02 /* Check if this is the only message marked */
|
|
};
|
|
|
|
/* signal event masks */
|
|
enum {
|
|
S_INPUT = 0x01, /* A non-M_PCPROTO message has arrived */
|
|
S_HIPRI = 0x02, /* A priority (M_PCPROTO) message is available */
|
|
S_OUTPUT = 0x04, /* The write queue is no longer full */
|
|
S_MSG = 0x08, /* A signal message has reached the front of read queue */
|
|
S_RDNORM = 0x10, /* A non-priority message is available */
|
|
S_RDBAND = 0x20, /* A banded messsage is available */
|
|
S_WRNORM = 0x40, /* Same as S_OUTPUT */
|
|
S_WRBAND = 0x80, /* A priority band exists and is writable */
|
|
S_ERROR = 0x0100, /* Error message has arrived */
|
|
S_HANGUP = 0x0200, /* Hangup message has arrived */
|
|
S_BANDURG = 0x0400 /* Use SIGURG instead of SIGPOLL on S_RDBAND signals */
|
|
};
|
|
|
|
/* read mode bits for I_S|GRDOPT; choose one of the following */
|
|
enum {
|
|
RNORM = 0x01, /* byte-stream mode, default */
|
|
RMSGD = 0x02, /* message-discard mode */
|
|
RMSGN = 0x04, /* message-nondiscard mode */
|
|
RFILL = 0x08 /* fill read buffer mode (PSE private) */
|
|
};
|
|
|
|
/* More read modes, these are bitwise or'ed with the modes above */
|
|
enum {
|
|
RPROTNORM = 0x10, /* Normal handling of M_PROTO/M_PCPROTO messages, default */
|
|
RPROTDIS = 0x20, /* Discard M_PROTO/M_PCPROTO message blocks */
|
|
RPROTDAT = 0x40 /* Convert M_PROTO/M_PCPROTO message blocks into M_DATA */
|
|
};
|
|
|
|
/* write modes for I_S|GWROPT */
|
|
enum {
|
|
SNDZERO = 0x01 /* Send a zero-length message downstream on a write of zero bytes */
|
|
};
|
|
|
|
enum {
|
|
MUXID_ALL = -1 /* Unlink all lower streams for I_UNLINK and I_PUNLINK */
|
|
};
|
|
|
|
/*
|
|
strbuf is moved to "OpenTransport.h" because that header file
|
|
exports provider routines that take it as a parameter.
|
|
*/
|
|
|
|
/* structure of ioctl data on I_FDINSERT */
|
|
struct strfdinsert {
|
|
strbuf ctlbuf;
|
|
strbuf databuf;
|
|
long flags; /* type of message, 0 or RS_HIPRI */
|
|
long fildes; /* fd of other stream (FDCELL) */
|
|
SInt32 offset; /* where to put other stream read qp */
|
|
};
|
|
typedef struct strfdinsert strfdinsert;
|
|
/* I_LIST structures */
|
|
struct str_mlist {
|
|
char l_name[32];
|
|
};
|
|
typedef struct str_mlist str_mlist;
|
|
struct str_list {
|
|
SInt32 sl_nmods; /* number of modules in sl_modlist array */
|
|
str_mlist * sl_modlist;
|
|
};
|
|
typedef struct str_list str_list;
|
|
/* I_PEEK structure */
|
|
struct strpeek {
|
|
strbuf ctlbuf;
|
|
strbuf databuf;
|
|
long flags; /* if RS_HIPRI, get priority messages only */
|
|
};
|
|
typedef struct strpeek strpeek;
|
|
/* structure for getpmsg and putpmsg */
|
|
struct strpmsg {
|
|
strbuf ctlbuf;
|
|
strbuf databuf;
|
|
SInt32 band;
|
|
long flags;
|
|
};
|
|
typedef struct strpmsg strpmsg;
|
|
/* structure of ioctl data on I_RECVFD */
|
|
struct strrecvfd {
|
|
long fd; /* new file descriptor (FDCELL) */
|
|
unsigned short uid; /* user id of sending stream */
|
|
unsigned short gid;
|
|
char fill[8];
|
|
};
|
|
typedef struct strrecvfd strrecvfd;
|
|
/* structure of ioctl data on I_STR */
|
|
struct strioctl {
|
|
SInt32 ic_cmd; /* downstream command */
|
|
SInt32 ic_timout; /* ACK/NAK timeout */
|
|
SInt32 ic_len; /* length of data arg */
|
|
char * ic_dp; /* ptr to data arg */
|
|
};
|
|
typedef struct strioctl strioctl;
|
|
/* ***** From the Mentat "strlog.h" ******/
|
|
|
|
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;
|
|
enum {
|
|
SL_FATAL = 0x01, /* Fatal error */
|
|
SL_NOTIFY = 0x02, /* Notify the system administrator */
|
|
SL_ERROR = 0x04, /* Pass message to error logger */
|
|
SL_TRACE = 0x08, /* Pass message to tracer */
|
|
SL_CONSOLE = 0x00, /* Console messages are disabled */
|
|
SL_WARN = 0x20, /* Warning */
|
|
SL_NOTE = 0x40 /* Notice this message */
|
|
};
|
|
|
|
struct trace_ids {
|
|
short ti_mid;
|
|
short ti_sid;
|
|
char ti_level;
|
|
};
|
|
typedef struct trace_ids trace_ids;
|
|
enum {
|
|
I_TRCLOG = ((MIOC_STRLOG << 8) | 1),
|
|
I_ERRLOG = ((MIOC_STRLOG << 8) | 2)
|
|
};
|
|
|
|
enum {
|
|
LOGMSGSZ = 128
|
|
};
|
|
|
|
/* ***** From the Mentat "tihdr.h" ******/
|
|
|
|
#if CALL_NOT_IN_CARBON
|
|
|
|
/* TPI Primitives*/
|
|
|
|
|
|
|
|
enum {
|
|
T_BIND_REQ = 101,
|
|
T_CONN_REQ = 102, /* connection request */
|
|
T_CONN_RES = 103, /* respond to connection indication */
|
|
T_DATA_REQ = 104,
|
|
T_DISCON_REQ = 105,
|
|
T_EXDATA_REQ = 106,
|
|
T_INFO_REQ = 107,
|
|
T_OPTMGMT_REQ = 108,
|
|
T_ORDREL_REQ = 109,
|
|
T_UNBIND_REQ = 110,
|
|
T_UNITDATA_REQ = 111,
|
|
T_ADDR_REQ = 112, /* Get address request */
|
|
T_UREQUEST_REQ = 113, /* UnitRequest (transaction) req */
|
|
T_REQUEST_REQ = 114, /* Request (CO transaction) req */
|
|
T_UREPLY_REQ = 115, /* UnitRequest (transaction) req */
|
|
T_REPLY_REQ = 116, /* REPLY (CO transaction) req */
|
|
T_CANCELREQUEST_REQ = 117, /* Cancel outgoing request */
|
|
T_CANCELREPLY_REQ = 118, /* Cancel incoming request */
|
|
T_REGNAME_REQ = 119, /* Request name registration */
|
|
T_DELNAME_REQ = 120, /* Request delete name registration */
|
|
T_LKUPNAME_REQ = 121, /* Request name lookup */
|
|
|
|
T_BIND_ACK = 122,
|
|
T_CONN_CON = 123, /* connection confirmation */
|
|
T_CONN_IND = 124, /* incoming connection indication */
|
|
T_DATA_IND = 125,
|
|
T_DISCON_IND = 126,
|
|
T_ERROR_ACK = 127,
|
|
T_EXDATA_IND = 128,
|
|
T_INFO_ACK = 129,
|
|
T_OK_ACK = 130,
|
|
T_OPTMGMT_ACK = 131,
|
|
T_ORDREL_IND = 132,
|
|
T_UNITDATA_IND = 133,
|
|
T_UDERROR_IND = 134,
|
|
T_ADDR_ACK = 135, /* Get address ack */
|
|
T_UREQUEST_IND = 136, /* UnitRequest (transaction) ind */
|
|
T_REQUEST_IND = 137, /* Request (CO transaction) ind */
|
|
T_UREPLY_IND = 138, /* Incoming unit reply */
|
|
T_REPLY_IND = 139, /* Incoming reply */
|
|
T_UREPLY_ACK = 140, /* outgoing Unit Reply is complete */
|
|
T_REPLY_ACK = 141, /* outgoing Reply is complete */
|
|
T_RESOLVEADDR_REQ = 142,
|
|
T_RESOLVEADDR_ACK = 143,
|
|
|
|
T_LKUPNAME_CON = 146, /* Results of name lookup */
|
|
T_LKUPNAME_RES = 147, /* Partial results of name lookup */
|
|
T_REGNAME_ACK = 148, /* Request name registration */
|
|
T_SEQUENCED_ACK = 149, /* Sequenced version of OK or ERROR ACK */
|
|
|
|
T_EVENT_IND = 160 /* Miscellaneous event Indication */
|
|
};
|
|
|
|
/* State values */
|
|
enum {
|
|
TS_UNBND = 1,
|
|
TS_WACK_BREQ = 2,
|
|
TS_WACK_UREQ = 3,
|
|
TS_IDLE = 4,
|
|
TS_WACK_OPTREQ = 5,
|
|
TS_WACK_CREQ = 6,
|
|
TS_WCON_CREQ = 7,
|
|
TS_WRES_CIND = 8,
|
|
TS_WACK_CRES = 9,
|
|
TS_DATA_XFER = 10,
|
|
TS_WIND_ORDREL = 11,
|
|
TS_WREQ_ORDREL = 12,
|
|
TS_WACK_DREQ6 = 13,
|
|
TS_WACK_DREQ7 = 14,
|
|
TS_WACK_DREQ9 = 15,
|
|
TS_WACK_DREQ10 = 16,
|
|
TS_WACK_DREQ11 = 17,
|
|
TS_WACK_ORDREL = 18,
|
|
TS_NOSTATES = 19,
|
|
TS_BAD_STATE = 19
|
|
};
|
|
|
|
/* Transport events */
|
|
enum {
|
|
TE_OPENED = 1,
|
|
TE_BIND = 2,
|
|
TE_OPTMGMT = 3,
|
|
TE_UNBIND = 4,
|
|
TE_CLOSED = 5,
|
|
TE_CONNECT1 = 6,
|
|
TE_CONNECT2 = 7,
|
|
TE_ACCEPT1 = 8,
|
|
TE_ACCEPT2 = 9,
|
|
TE_ACCEPT3 = 10,
|
|
TE_SND = 11,
|
|
TE_SNDDIS1 = 12,
|
|
TE_SNDDIS2 = 13,
|
|
TE_SNDREL = 14,
|
|
TE_SNDUDATA = 15,
|
|
TE_LISTEN = 16,
|
|
TE_RCVCONNECT = 17,
|
|
TE_RCV = 18,
|
|
TE_RCVDIS1 = 19,
|
|
TE_RCVDIS2 = 20,
|
|
TE_RCVDIS3 = 21,
|
|
TE_RCVREL = 22,
|
|
TE_RCVUDATA = 23,
|
|
TE_RCVUDERR = 24,
|
|
TE_PASS_CONN = 25,
|
|
TE_BAD_EVENT = 26
|
|
};
|
|
|
|
struct T_addr_ack {
|
|
long PRIM_type; /* Always T_ADDR_ACK */
|
|
long LOCADDR_length;
|
|
long LOCADDR_offset;
|
|
long REMADDR_length;
|
|
long REMADDR_offset;
|
|
};
|
|
typedef struct T_addr_ack T_addr_ack;
|
|
struct T_addr_req {
|
|
long PRIM_type; /* Always T_ADDR_REQ */
|
|
};
|
|
typedef struct T_addr_req T_addr_req;
|
|
struct T_bind_ack {
|
|
long PRIM_type; /* always T_BIND_ACK */
|
|
long ADDR_length;
|
|
long ADDR_offset;
|
|
unsigned long CONIND_number;
|
|
};
|
|
typedef struct T_bind_ack T_bind_ack;
|
|
struct T_bind_req {
|
|
long PRIM_type; /* always T_BIND_REQ */
|
|
long ADDR_length;
|
|
long ADDR_offset;
|
|
unsigned long CONIND_number;
|
|
};
|
|
typedef struct T_bind_req T_bind_req;
|
|
struct T_conn_con {
|
|
long PRIM_type; /* always T_CONN_CON */
|
|
long RES_length; /* responding address length */
|
|
long RES_offset;
|
|
long OPT_length;
|
|
long OPT_offset;
|
|
};
|
|
typedef struct T_conn_con T_conn_con;
|
|
struct T_conn_ind {
|
|
long PRIM_type; /* always T_CONN_IND */
|
|
long SRC_length;
|
|
long SRC_offset;
|
|
long OPT_length;
|
|
long OPT_offset;
|
|
long SEQ_number;
|
|
};
|
|
typedef struct T_conn_ind T_conn_ind;
|
|
struct T_conn_req {
|
|
long PRIM_type; /* always T_CONN_REQ */
|
|
long DEST_length;
|
|
long DEST_offset;
|
|
long OPT_length;
|
|
long OPT_offset;
|
|
};
|
|
typedef struct T_conn_req T_conn_req;
|
|
struct T_conn_res {
|
|
long PRIM_type; /* always T_CONN_RES */
|
|
queue_t * QUEUE_ptr;
|
|
long OPT_length;
|
|
long OPT_offset;
|
|
long SEQ_number;
|
|
};
|
|
typedef struct T_conn_res T_conn_res;
|
|
struct T_data_ind {
|
|
long PRIM_type; /* always T_DATA_IND */
|
|
long MORE_flag;
|
|
};
|
|
typedef struct T_data_ind T_data_ind;
|
|
struct T_data_req {
|
|
long PRIM_type; /* always T_DATA_REQ */
|
|
long MORE_flag;
|
|
};
|
|
typedef struct T_data_req T_data_req;
|
|
struct T_discon_ind {
|
|
long PRIM_type; /* always T_DISCON_IND */
|
|
long DISCON_reason;
|
|
long SEQ_number;
|
|
};
|
|
typedef struct T_discon_ind T_discon_ind;
|
|
struct T_discon_req {
|
|
long PRIM_type; /* always T_DISCON_REQ */
|
|
long SEQ_number;
|
|
};
|
|
typedef struct T_discon_req T_discon_req;
|
|
struct T_exdata_ind {
|
|
long PRIM_type; /* always T_EXDATA_IND */
|
|
long MORE_flag;
|
|
};
|
|
typedef struct T_exdata_ind T_exdata_ind;
|
|
struct T_exdata_req {
|
|
long PRIM_type; /* always T_EXDATA_REQ */
|
|
long MORE_flag;
|
|
};
|
|
typedef struct T_exdata_req T_exdata_req;
|
|
struct T_error_ack {
|
|
long PRIM_type; /* always T_ERROR_ACK */
|
|
long ERROR_prim; /* primitive in error */
|
|
long TLI_error;
|
|
long UNIX_error;
|
|
};
|
|
typedef struct T_error_ack T_error_ack;
|
|
struct T_info_ack {
|
|
long PRIM_type; /* always T_INFO_ACK */
|
|
long TSDU_size; /* max TSDU size */
|
|
long ETSDU_size; /* max ETSDU size */
|
|
long CDATA_size; /* connect data size */
|
|
long DDATA_size; /* disconnect data size */
|
|
long ADDR_size; /* TSAP size */
|
|
long OPT_size; /* options size */
|
|
long TIDU_size; /* TIDU size */
|
|
long SERV_type; /* service type */
|
|
long CURRENT_state; /* current state */
|
|
long PROVIDER_flag; /* provider flags (see xti.h for defines) */
|
|
};
|
|
typedef struct T_info_ack T_info_ack;
|
|
/* Provider flags */
|
|
enum {
|
|
SENDZERO = 0x0001, /* supports 0-length TSDU's */
|
|
XPG4_1 = 0x0002 /* provider supports recent stuff */
|
|
};
|
|
|
|
struct T_info_req {
|
|
long PRIM_type; /* always T_INFO_REQ */
|
|
};
|
|
typedef struct T_info_req T_info_req;
|
|
struct T_ok_ack {
|
|
long PRIM_type; /* always T_OK_ACK */
|
|
long CORRECT_prim;
|
|
};
|
|
typedef struct T_ok_ack T_ok_ack;
|
|
struct T_optmgmt_ack {
|
|
long PRIM_type; /* always T_OPTMGMT_ACK */
|
|
long OPT_length;
|
|
long OPT_offset;
|
|
long MGMT_flags;
|
|
};
|
|
typedef struct T_optmgmt_ack T_optmgmt_ack;
|
|
struct T_optmgmt_req {
|
|
long PRIM_type; /* always T_OPTMGMT_REQ */
|
|
long OPT_length;
|
|
long OPT_offset;
|
|
long MGMT_flags;
|
|
};
|
|
typedef struct T_optmgmt_req T_optmgmt_req;
|
|
struct T_ordrel_ind {
|
|
long PRIM_type; /* always T_ORDREL_IND */
|
|
};
|
|
typedef struct T_ordrel_ind T_ordrel_ind;
|
|
struct T_ordrel_req {
|
|
long PRIM_type; /* always T_ORDREL_REQ */
|
|
};
|
|
typedef struct T_ordrel_req T_ordrel_req;
|
|
struct T_unbind_req {
|
|
long PRIM_type; /* always T_UNBIND_REQ */
|
|
};
|
|
typedef struct T_unbind_req T_unbind_req;
|
|
struct T_uderror_ind {
|
|
long PRIM_type; /* always T_UDERROR_IND */
|
|
long DEST_length;
|
|
long DEST_offset;
|
|
long OPT_length;
|
|
long OPT_offset;
|
|
long ERROR_type;
|
|
};
|
|
typedef struct T_uderror_ind T_uderror_ind;
|
|
struct T_unitdata_ind {
|
|
long PRIM_type; /* always T_UNITDATA_IND */
|
|
long SRC_length;
|
|
long SRC_offset;
|
|
long OPT_length;
|
|
long OPT_offset;
|
|
};
|
|
typedef struct T_unitdata_ind T_unitdata_ind;
|
|
struct T_unitdata_req {
|
|
long PRIM_type; /* always T_UNITDATA_REQ */
|
|
long DEST_length;
|
|
long DEST_offset;
|
|
long OPT_length;
|
|
long OPT_offset;
|
|
};
|
|
typedef struct T_unitdata_req T_unitdata_req;
|
|
struct T_resolveaddr_ack {
|
|
long PRIM_type; /* always T_RESOLVEADDR_ACK */
|
|
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;
|
|
struct T_resolveaddr_req {
|
|
long PRIM_type; /* always T_RESOLVEADDR_REQ */
|
|
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;
|
|
struct T_unitreply_ind {
|
|
long PRIM_type; /* Always T_UREPLY_IND */
|
|
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;
|
|
struct T_unitrequest_ind {
|
|
long PRIM_type; /* Always T_UREQUEST_IND */
|
|
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;
|
|
struct T_unitrequest_req {
|
|
long PRIM_type; /* Always T_UREQUEST_REQ */
|
|
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;
|
|
struct T_unitreply_req {
|
|
long PRIM_type; /* Always T_UREPLY_REQ */
|
|
long SEQ_number;
|
|
long OPT_length;
|
|
long OPT_offset;
|
|
long REP_flags;
|
|
};
|
|
typedef struct T_unitreply_req T_unitreply_req;
|
|
struct T_unitreply_ack {
|
|
long PRIM_type; /* Always T_UREPLY_ACK */
|
|
long SEQ_number;
|
|
long TLI_error;
|
|
long UNIX_error;
|
|
};
|
|
typedef struct T_unitreply_ack T_unitreply_ack;
|
|
struct T_cancelrequest_req {
|
|
long PRIM_type; /* Always T_CANCELREQUEST_REQ */
|
|
long SEQ_number;
|
|
};
|
|
typedef struct T_cancelrequest_req T_cancelrequest_req;
|
|
struct T_cancelreply_req {
|
|
long PRIM_type; /* Always T_CANCELREPLY_REQ */
|
|
long SEQ_number;
|
|
};
|
|
typedef struct T_cancelreply_req T_cancelreply_req;
|
|
struct T_reply_ind {
|
|
long PRIM_type; /* Always T_REPLY_IND */
|
|
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;
|
|
struct T_request_ind {
|
|
long PRIM_type; /* Always T_REQUEST_IND */
|
|
long SEQ_number;
|
|
long OPT_length;
|
|
long OPT_offset;
|
|
long REQ_flags;
|
|
};
|
|
typedef struct T_request_ind T_request_ind;
|
|
struct T_request_req {
|
|
long PRIM_type; /* Always T_REQUEST_REQ */
|
|
long SEQ_number;
|
|
long OPT_length;
|
|
long OPT_offset;
|
|
long REQ_flags;
|
|
};
|
|
typedef struct T_request_req T_request_req;
|
|
struct T_reply_req {
|
|
long PRIM_type; /* Always T_REPLY_REQ */
|
|
long SEQ_number;
|
|
long OPT_length;
|
|
long OPT_offset;
|
|
long REP_flags;
|
|
};
|
|
typedef struct T_reply_req T_reply_req;
|
|
struct T_reply_ack {
|
|
long PRIM_type; /* Always T_REPLY_ACK */
|
|
long SEQ_number;
|
|
long TLI_error;
|
|
long UNIX_error;
|
|
};
|
|
typedef struct T_reply_ack T_reply_ack;
|
|
struct T_regname_req {
|
|
long PRIM_type; /* Always T_REGNAME_REQ */
|
|
long SEQ_number; /* Reply is sequence ack */
|
|
long NAME_length;
|
|
long NAME_offset;
|
|
long ADDR_length;
|
|
long ADDR_offset;
|
|
long REQ_flags;
|
|
};
|
|
typedef struct T_regname_req T_regname_req;
|
|
struct T_regname_ack {
|
|
long PRIM_type; /* always T_REGNAME_ACK */
|
|
long SEQ_number;
|
|
long REG_id;
|
|
long ADDR_length;
|
|
long ADDR_offset;
|
|
};
|
|
typedef struct T_regname_ack T_regname_ack;
|
|
struct T_delname_req {
|
|
long PRIM_type; /* Always T_DELNAME_REQ */
|
|
long SEQ_number; /* Reply is sequence ack */
|
|
long NAME_length;
|
|
long NAME_offset;
|
|
};
|
|
typedef struct T_delname_req T_delname_req;
|
|
struct T_lkupname_req {
|
|
long PRIM_type; /* Always T_LKUPNAME_REQ */
|
|
long SEQ_number; /* Reply is sequence ack */
|
|
long NAME_length; /* ... or T_LKUPNAME_CON */
|
|
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;
|
|
struct T_lkupname_con {
|
|
long PRIM_type; /* Either T_LKUPNAME_CON */
|
|
long SEQ_number; /* Or T_LKUPNAME_RES */
|
|
long NAME_length;
|
|
long NAME_offset;
|
|
long RSP_count;
|
|
long RSP_cumcount;
|
|
};
|
|
typedef struct T_lkupname_con T_lkupname_con;
|
|
struct T_sequence_ack {
|
|
long PRIM_type; /* always T_SEQUENCED_ACK */
|
|
long ORIG_prim; /* original primitive */
|
|
long SEQ_number;
|
|
long TLI_error;
|
|
long UNIX_error;
|
|
};
|
|
typedef struct T_sequence_ack T_sequence_ack;
|
|
struct T_event_ind {
|
|
long PRIM_type; /* always T_EVENT_IND */
|
|
long EVENT_code;
|
|
long EVENT_cookie;
|
|
};
|
|
typedef struct T_event_ind T_event_ind;
|
|
union T_primitives {
|
|
long type;
|
|
|
|
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;
|
|
/* ***** From the Mentat "dlpi.h" ******/
|
|
|
|
/*
|
|
This header file has encoded the values so an existing driver
|
|
or user which was written with the Logical Link Interface(LLI)
|
|
can migrate to the DLPI interface in a binary compatible manner.
|
|
Any fields which require a specific format or value are flagged
|
|
with a comment containing the message LLI compatibility.
|
|
*/
|
|
|
|
/* DLPI revision definition history*/
|
|
|
|
enum {
|
|
DL_CURRENT_VERSION = 0x02, /* current version of dlpi */
|
|
DL_VERSION_2 = 0x02 /* version of dlpi March 12,1991 */
|
|
};
|
|
|
|
|
|
enum {
|
|
DL_INFO_REQ = 0x00, /* Information Req, LLI compatibility */
|
|
DL_INFO_ACK = 0x03, /* Information Ack, LLI compatibility */
|
|
DL_ATTACH_REQ = 0x0B, /* Attach a PPA */
|
|
DL_DETACH_REQ = 0x0C, /* Detach a PPA */
|
|
DL_BIND_REQ = 0x01, /* Bind dlsap address, LLI compatibility */
|
|
DL_BIND_ACK = 0x04, /* Dlsap address bound, LLI compatibility */
|
|
DL_UNBIND_REQ = 0x02, /* Unbind dlsap address, LLI compatibility */
|
|
DL_OK_ACK = 0x06, /* Success acknowledgment, LLI compatibility */
|
|
DL_ERROR_ACK = 0x05, /* Error acknowledgment, LLI compatibility */
|
|
DL_SUBS_BIND_REQ = 0x1B, /* Bind Subsequent DLSAP address */
|
|
DL_SUBS_BIND_ACK = 0x1C, /* Subsequent DLSAP address bound */
|
|
DL_SUBS_UNBIND_REQ = 0x15, /* Subsequent unbind */
|
|
DL_ENABMULTI_REQ = 0x1D, /* Enable multicast addresses */
|
|
DL_DISABMULTI_REQ = 0x1E, /* Disable multicast addresses */
|
|
DL_PROMISCON_REQ = 0x1F, /* Turn on promiscuous mode */
|
|
DL_PROMISCOFF_REQ = 0x20, /* Turn off promiscuous mode */
|
|
DL_UNITDATA_REQ = 0x07, /* datagram send request, LLI compatibility */
|
|
DL_UNITDATA_IND = 0x08, /* datagram receive indication, LLI compatibility */
|
|
DL_UDERROR_IND = 0x09, /* datagram error indication, LLI compatibility */
|
|
DL_UDQOS_REQ = 0x0A, /* set QOS for subsequent datagram transmissions */
|
|
DL_CONNECT_REQ = 0x0D, /* Connect request */
|
|
DL_CONNECT_IND = 0x0E, /* Incoming connect indication */
|
|
DL_CONNECT_RES = 0x0F, /* Accept previous connect indication */
|
|
DL_CONNECT_CON = 0x10, /* Connection established */
|
|
DL_TOKEN_REQ = 0x11, /* Passoff token request */
|
|
DL_TOKEN_ACK = 0x12, /* Passoff token ack */
|
|
DL_DISCONNECT_REQ = 0x13, /* Disconnect request */
|
|
DL_DISCONNECT_IND = 0x14, /* Disconnect indication */
|
|
DL_RESET_REQ = 0x17, /* Reset service request */
|
|
DL_RESET_IND = 0x18, /* Incoming reset indication */
|
|
DL_RESET_RES = 0x19, /* Complete reset processing */
|
|
DL_RESET_CON = 0x1A, /* Reset processing complete */
|
|
DL_DATA_ACK_REQ = 0x21, /* data unit transmission request */
|
|
DL_DATA_ACK_IND = 0x22, /* Arrival of a command PDU */
|
|
DL_DATA_ACK_STATUS_IND = 0x23, /* Status indication of DATA_ACK_REQ*/
|
|
DL_REPLY_REQ = 0x24, /* Request a DLSDU from the remote */
|
|
DL_REPLY_IND = 0x25, /* Arrival of a command PDU */
|
|
DL_REPLY_STATUS_IND = 0x26, /* Status indication of REPLY_REQ */
|
|
DL_REPLY_UPDATE_REQ = 0x27, /* Hold a DLSDU for transmission */
|
|
DL_REPLY_UPDATE_STATUS_IND = 0x28, /* Status of REPLY_UPDATE req */
|
|
DL_XID_REQ = 0x29, /* Request to send an XID PDU */
|
|
DL_XID_IND = 0x2A, /* Arrival of an XID PDU */
|
|
DL_XID_RES = 0x2B, /* request to send a response XID PDU*/
|
|
DL_XID_CON = 0x2C, /* Arrival of a response XID PDU */
|
|
DL_TEST_REQ = 0x2D, /* TEST command request */
|
|
DL_TEST_IND = 0x2E, /* TEST response indication */
|
|
DL_TEST_RES = 0x2F, /* TEST response */
|
|
DL_TEST_CON = 0x30, /* TEST Confirmation */
|
|
DL_PHYS_ADDR_REQ = 0x31, /* Request to get physical addr */
|
|
DL_PHYS_ADDR_ACK = 0x32, /* Return physical addr */
|
|
DL_SET_PHYS_ADDR_REQ = 0x33, /* set physical addr */
|
|
DL_GET_STATISTICS_REQ = 0x34, /* Request to get statistics */
|
|
DL_GET_STATISTICS_ACK = 0x35 /* Return statistics */
|
|
};
|
|
|
|
/* DLPI interface states*/
|
|
enum {
|
|
DL_UNATTACHED = 0x04, /* PPA not attached */
|
|
DL_ATTACH_PENDING = 0x05, /* Waiting ack of DL_ATTACH_REQ */
|
|
DL_DETACH_PENDING = 0x06, /* Waiting ack of DL_DETACH_REQ */
|
|
DL_UNBOUND = 0x00, /* PPA attached, LLI compatibility */
|
|
DL_BIND_PENDING = 0x01, /* Waiting ack of DL_BIND_REQ, LLI compatibility */
|
|
DL_UNBIND_PENDING = 0x02, /* Waiting ack of DL_UNBIND_REQ, LLI compatibility */
|
|
DL_IDLE = 0x03, /* dlsap bound, awaiting use, LLI compatibility */
|
|
DL_UDQOS_PENDING = 0x07, /* Waiting ack of DL_UDQOS_REQ */
|
|
DL_OUTCON_PENDING = 0x08, /* outgoing connection, awaiting DL_CONN_CON */
|
|
DL_INCON_PENDING = 0x09, /* incoming connection, awaiting DL_CONN_RES */
|
|
DL_CONN_RES_PENDING = 0x0A, /* Waiting ack of DL_CONNECT_RES */
|
|
DL_DATAXFER = 0x0B, /* connection-oriented data transfer */
|
|
DL_USER_RESET_PENDING = 0x0C, /* user initiated reset, awaiting DL_RESET_CON */
|
|
DL_PROV_RESET_PENDING = 0x0D, /* provider initiated reset, awaiting DL_RESET_RES */
|
|
DL_RESET_RES_PENDING = 0x0E, /* Waiting ack of DL_RESET_RES */
|
|
DL_DISCON8_PENDING = 0x0F, /* Waiting ack of DL_DISC_REQ when in DL_OUTCON_PENDING */
|
|
DL_DISCON9_PENDING = 0x10, /* Waiting ack of DL_DISC_REQ when in DL_INCON_PENDING */
|
|
DL_DISCON11_PENDING = 0x11, /* Waiting ack of DL_DISC_REQ when in DL_DATAXFER */
|
|
DL_DISCON12_PENDING = 0x12, /* Waiting ack of DL_DISC_REQ when in DL_USER_RESET_PENDING */
|
|
DL_DISCON13_PENDING = 0x13, /* Waiting ack of DL_DISC_REQ when in DL_DL_PROV_RESET_PENDING */
|
|
DL_SUBS_BIND_PND = 0x14, /* Waiting ack of DL_SUBS_BIND_REQ */
|
|
DL_SUBS_UNBIND_PND = 0x15 /* Waiting ack of DL_SUBS_UNBIND_REQ */
|
|
};
|
|
|
|
/* DL_ERROR_ACK error return values*/
|
|
|
|
enum {
|
|
DL_ACCESS = 0x02, /* Improper permissions for request, LLI compatibility */
|
|
DL_BADADDR = 0x01, /* DLSAP address in improper format or invalid */
|
|
DL_BADCORR = 0x05, /* Sequence number not from outstanding DL_CONN_IND */
|
|
DL_BADDATA = 0x06, /* User data exceeded provider limit */
|
|
DL_BADPPA = 0x08, /* Specified PPA was invalid */
|
|
DL_BADPRIM = 0x09, /* Primitive received is not known by DLS provider */
|
|
DL_BADQOSPARAM = 0x0A, /* QOS parameters contained invalid values */
|
|
DL_BADQOSTYPE = 0x0B, /* QOS structure type is unknown or unsupported */
|
|
DL_BADSAP = 0x00, /* Bad LSAP selector, LLI compatibility */
|
|
DL_BADTOKEN = 0x0C, /* Token used not associated with an active stream */
|
|
DL_BOUND = 0x0D, /* Attempted second bind with dl_max_conind or */
|
|
/* dl_conn_mgmt > 0 on same DLSAP or PPA */
|
|
DL_INITFAILED = 0x0E, /* Physical Link initialization failed */
|
|
DL_NOADDR = 0x0F, /* Provider couldn't allocate alternate address */
|
|
DL_NOTINIT = 0x10, /* Physical Link not initialized */
|
|
DL_OUTSTATE = 0x03, /* Primitive issued in improper state, LLI compatibility */
|
|
DL_SYSERR = 0x04, /* UNIX system error occurred, LLI compatibility */
|
|
DL_UNSUPPORTED = 0x07, /* Requested service not supplied by provider */
|
|
DL_UNDELIVERABLE = 0x11, /* Previous data unit could not be delivered */
|
|
DL_NOTSUPPORTED = 0x12, /* Primitive is known but not supported by DLS provider */
|
|
DL_TOOMANY = 0x13, /* limit exceeded */
|
|
DL_NOTENAB = 0x14, /* Promiscuous mode not enabled */
|
|
DL_BUSY = 0x15, /* Other streams for a particular PPA in the post-attached state */
|
|
DL_NOAUTO = 0x16, /* Automatic handling of XID & TEST responses not supported */
|
|
DL_NOXIDAUTO = 0x17, /* Automatic handling of XID not supported */
|
|
DL_NOTESTAUTO = 0x18, /* Automatic handling of TEST not supported */
|
|
DL_XIDAUTO = 0x19, /* Automatic handling of XID response */
|
|
DL_TESTAUTO = 0x1A, /* AUtomatic handling of TEST response*/
|
|
DL_PENDING = 0x1B /* pending outstanding connect indications */
|
|
};
|
|
|
|
/* DLPI media types supported*/
|
|
|
|
enum {
|
|
DL_CSMACD = 0x00, /* IEEE 802.3 CSMA/CD network, LLI Compatibility */
|
|
DL_TPB = 0x01, /* IEEE 802.4 Token Passing Bus, LLI Compatibility */
|
|
DL_TPR = 0x02, /* IEEE 802.5 Token Passing Ring, LLI Compatibility */
|
|
DL_METRO = 0x03, /* IEEE 802.6 Metro Net, LLI Compatibility */
|
|
DL_ETHER = 0x04, /* Ethernet Bus, LLI Compatibility */
|
|
DL_HDLC = 0x05, /* ISO HDLC protocol support, bit synchronous */
|
|
DL_CHAR = 0x06, /* Character Synchronous protocol support, eg BISYNC */
|
|
DL_CTCA = 0x07, /* IBM Channel-to-Channel Adapter */
|
|
DL_FDDI = 0x08, /* Fiber Distributed data interface */
|
|
DL_OTHER = 0x09 /* Any other medium not listed above */
|
|
};
|
|
|
|
/*
|
|
DLPI provider service supported.
|
|
These must be allowed to be bitwise-OR for dl_service_mode in
|
|
DL_INFO_ACK.
|
|
*/
|
|
enum {
|
|
DL_CODLS = 0x01, /* support connection-oriented service */
|
|
DL_CLDLS = 0x02, /* support connectionless data link service */
|
|
DL_ACLDLS = 0x04 /* support acknowledged connectionless service*/
|
|
};
|
|
|
|
/*
|
|
DLPI provider style.
|
|
The DLPI provider style which determines whether a provider
|
|
requires a DL_ATTACH_REQ to inform the provider which PPA
|
|
user messages should be sent/received on.
|
|
*/
|
|
|
|
enum {
|
|
DL_STYLE1 = 0x0500, /* PPA is implicitly bound by open(2) */
|
|
DL_STYLE2 = 0x0501 /* PPA must be explicitly bound via DL_ATTACH_REQ */
|
|
};
|
|
|
|
/* DLPI Originator for Disconnect and Resets*/
|
|
|
|
enum {
|
|
DL_PROVIDER = 0x0700,
|
|
DL_USER = 0x0701
|
|
};
|
|
|
|
/* DLPI Disconnect Reasons*/
|
|
|
|
enum {
|
|
DL_CONREJ_DEST_UNKNOWN = 0x0800,
|
|
DL_CONREJ_DEST_UNREACH_PERMANENT = 0x0801,
|
|
DL_CONREJ_DEST_UNREACH_TRANSIENT = 0x0802,
|
|
DL_CONREJ_QOS_UNAVAIL_PERMANENT = 0x0803,
|
|
DL_CONREJ_QOS_UNAVAIL_TRANSIENT = 0x0804,
|
|
DL_CONREJ_PERMANENT_COND = 0x0805,
|
|
DL_CONREJ_TRANSIENT_COND = 0x0806,
|
|
DL_DISC_ABNORMAL_CONDITION = 0x0807,
|
|
DL_DISC_NORMAL_CONDITION = 0x0808,
|
|
DL_DISC_PERMANENT_CONDITION = 0x0809,
|
|
DL_DISC_TRANSIENT_CONDITION = 0x080A,
|
|
DL_DISC_UNSPECIFIED = 0x080B
|
|
};
|
|
|
|
/* DLPI Reset Reasons*/
|
|
|
|
enum {
|
|
DL_RESET_FLOW_CONTROL = 0x0900,
|
|
DL_RESET_LINK_ERROR = 0x0901,
|
|
DL_RESET_RESYNCH = 0x0902
|
|
};
|
|
|
|
/* DLPI status values for acknowledged connectionless data transfer*/
|
|
|
|
enum {
|
|
DL_CMD_MASK = 0x0F, /* mask for command portion of status */
|
|
DL_CMD_OK = 0x00, /* Command Accepted */
|
|
DL_CMD_RS = 0x01, /* Unimplemented or inactivated service */
|
|
DL_CMD_UE = 0x05, /* Data Link User interface error */
|
|
DL_CMD_PE = 0x06, /* Protocol error */
|
|
DL_CMD_IP = 0x07, /* Permanent implementation dependent error*/
|
|
DL_CMD_UN = 0x09, /* Resources temporarily unavailable */
|
|
DL_CMD_IT = 0x0F, /* Temporary implementation dependent error */
|
|
DL_RSP_MASK = 0xF0, /* mask for response portion of status */
|
|
DL_RSP_OK = 0x00, /* Response DLSDU present */
|
|
DL_RSP_RS = 0x10, /* Unimplemented or inactivated service */
|
|
DL_RSP_NE = 0x30, /* Response DLSDU never submitted */
|
|
DL_RSP_NR = 0x40, /* Response DLSDU not requested */
|
|
DL_RSP_UE = 0x50, /* Data Link User interface error */
|
|
DL_RSP_IP = 0x70, /* Permanent implementation dependent error */
|
|
DL_RSP_UN = 0x90, /* Resources temporarily unavailable */
|
|
DL_RSP_IT = 0xF0 /* Temporary implementation dependent error */
|
|
};
|
|
|
|
/* Service Class values for acknowledged connectionless data transfer*/
|
|
|
|
enum {
|
|
DL_RQST_RSP = 0x01, /* Use acknowledge capability in MAC sublayer*/
|
|
DL_RQST_NORSP = 0x02 /* No acknowledgement service requested */
|
|
};
|
|
|
|
/* DLPI address type definition*/
|
|
|
|
enum {
|
|
DL_FACT_PHYS_ADDR = 0x01, /* factory physical address */
|
|
DL_CURR_PHYS_ADDR = 0x02 /* current physical address */
|
|
};
|
|
|
|
/* DLPI flag definitions*/
|
|
|
|
enum {
|
|
DL_POLL_FINAL = 0x01 /* if set,indicates poll/final bit set*/
|
|
};
|
|
|
|
/* XID and TEST responses supported by the provider*/
|
|
|
|
enum {
|
|
DL_AUTO_XID = 0x01, /* provider will respond to XID */
|
|
DL_AUTO_TEST = 0x02 /* provider will respond to TEST */
|
|
};
|
|
|
|
/* Subsequent bind type*/
|
|
|
|
enum {
|
|
DL_PEER_BIND = 0x01, /* subsequent bind on a peer addr */
|
|
DL_HIERARCHICAL_BIND = 0x02 /* subs_bind on a hierarchical addr*/
|
|
};
|
|
|
|
/* DLPI promiscuous mode definitions*/
|
|
|
|
enum {
|
|
DL_PROMISC_PHYS = 0x01, /* promiscuous mode at phys level */
|
|
DL_PROMISC_SAP = 0x02, /* promiscous mode at sap level */
|
|
DL_PROMISC_MULTI = 0x03 /* promiscuous mode for multicast */
|
|
};
|
|
|
|
/* M_DATA "raw" mode */
|
|
#define DLIOCRAW MIOC_CMD(MIOC_DLPI,1)
|
|
/*
|
|
DLPI Quality Of Service definition for use in QOS structure definitions.
|
|
The QOS structures are used in connection establishment, DL_INFO_ACK,
|
|
and setting connectionless QOS values.
|
|
*/
|
|
/*
|
|
Throughput
|
|
|
|
This parameter is specified for both directions.
|
|
*/
|
|
|
|
struct dl_through_t {
|
|
SInt32 dl_target_value; /* desired bits/second desired */
|
|
SInt32 dl_accept_value; /* min. acceptable bits/second */
|
|
};
|
|
typedef struct dl_through_t dl_through_t;
|
|
/*
|
|
transit delay specification
|
|
|
|
This parameter is specified for both directions.
|
|
expressed in milliseconds assuming a DLSDU size of 128 octets.
|
|
The scaling of the value to the current DLSDU size is provider dependent.
|
|
*/
|
|
struct dl_transdelay_t {
|
|
SInt32 dl_target_value; /* desired value of service */
|
|
SInt32 dl_accept_value; /* min. acceptable value of service */
|
|
};
|
|
typedef struct dl_transdelay_t dl_transdelay_t;
|
|
/*
|
|
priority specification
|
|
priority range is 0-100, with 0 being highest value.
|
|
*/
|
|
|
|
struct dl_priority_t {
|
|
SInt32 dl_min;
|
|
SInt32 dl_max;
|
|
};
|
|
typedef struct dl_priority_t dl_priority_t;
|
|
/* protection specification*/
|
|
enum {
|
|
DL_NONE = 0x0B01, /* no protection supplied */
|
|
DL_MONITOR = 0x0B02, /* protection against passive monitoring */
|
|
DL_MAXIMUM = 0x0B03 /* protection against modification, replay, addition, or deletion */
|
|
};
|
|
|
|
struct dl_protect_t {
|
|
SInt32 dl_min;
|
|
SInt32 dl_max;
|
|
};
|
|
typedef struct dl_protect_t dl_protect_t;
|
|
/*
|
|
Resilience specification
|
|
probabilities are scaled by a factor of 10,000 with a time interval
|
|
of 10,000 seconds.
|
|
*/
|
|
struct dl_resilience_t {
|
|
SInt32 dl_disc_prob; /* probability of provider init DISC */
|
|
SInt32 dl_reset_prob; /* probability of provider init RESET */
|
|
};
|
|
typedef struct dl_resilience_t dl_resilience_t;
|
|
/*
|
|
QOS type definition to be used for negotiation with the
|
|
remote end of a connection, or a connectionless unitdata request.
|
|
There are two type definitions to handle the negotiation
|
|
process at connection establishment. The typedef dl_qos_range_t
|
|
is used to present a range for parameters. This is used
|
|
in the DL_CONNECT_REQ and DL_CONNECT_IND messages. The typedef
|
|
dl_qos_sel_t is used to select a specific value for the QOS
|
|
parameters. This is used in the DL_CONNECT_RES, DL_CONNECT_CON,
|
|
and DL_INFO_ACK messages to define the selected QOS parameters
|
|
for a connection.
|
|
|
|
NOTE
|
|
A DataLink provider which has unknown values for any of the fields
|
|
will use a value of DL_UNKNOWN for all values in the fields.
|
|
|
|
NOTE
|
|
A QOS parameter value of DL_QOS_DONT_CARE informs the DLS
|
|
provider the user requesting this value doesn't care
|
|
what the QOS parameter is set to. This value becomes the
|
|
least possible value in the range of QOS parameters.
|
|
The order of the QOS parameter range is then:
|
|
|
|
DL_QOS_DONT_CARE < 0 < MAXIMUM QOS VALUE
|
|
*/
|
|
enum {
|
|
DL_UNKNOWN = -1,
|
|
DL_QOS_DONT_CARE = -2
|
|
};
|
|
|
|
/*
|
|
Every QOS structure has the first 4 bytes containing a type
|
|
field, denoting the definition of the rest of the structure.
|
|
This is used in the same manner has the dl_primitive variable
|
|
is in messages.
|
|
|
|
The following list is the defined QOS structure type values and structures.
|
|
*/
|
|
enum {
|
|
DL_QOS_CO_RANGE1 = 0x0101, /* QOS range struct. for Connection modeservice */
|
|
DL_QOS_CO_SEL1 = 0x0102, /* QOS selection structure */
|
|
DL_QOS_CL_RANGE1 = 0x0103, /* QOS range struct. for connectionless*/
|
|
DL_QOS_CL_SEL1 = 0x0104 /* QOS selection for connectionless mode*/
|
|
};
|
|
|
|
struct dl_qos_co_range1_t {
|
|
UInt32 dl_qos_type;
|
|
dl_through_t dl_rcv_throughput; /* desired and acceptable*/
|
|
dl_transdelay_t dl_rcv_trans_delay; /* desired and acceptable*/
|
|
dl_through_t dl_xmt_throughput;
|
|
dl_transdelay_t dl_xmt_trans_delay;
|
|
dl_priority_t dl_priority; /* min and max values */
|
|
dl_protect_t dl_protection; /* min and max values */
|
|
SInt32 dl_residual_error;
|
|
dl_resilience_t dl_resilience;
|
|
};
|
|
typedef struct dl_qos_co_range1_t dl_qos_co_range1_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;
|
|
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;
|
|
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;
|
|
/*
|
|
DLPI interface primitive definitions.
|
|
|
|
Each primitive is sent as a stream message. It is possible that
|
|
the messages may be viewed as a sequence of bytes that have the
|
|
following form without any padding. The structure definition
|
|
of the following messages may have to change depending on the
|
|
underlying hardware architecture and crossing of a hardware
|
|
boundary with a different hardware architecture.
|
|
|
|
Fields in the primitives having a name of the form
|
|
dl_reserved cannot be used and have the value of
|
|
binary zero, no bits turned on.
|
|
|
|
Each message has the name defined followed by the
|
|
stream message type (M_PROTO, M_PCPROTO, M_DATA)
|
|
*/
|
|
/* LOCAL MANAGEMENT SERVICE PRIMITIVES*/
|
|
|
|
/* DL_INFO_REQ, M_PCPROTO type*/
|
|
|
|
struct dl_info_req_t {
|
|
UInt32 dl_primitive; /* set to DL_INFO_REQ */
|
|
};
|
|
typedef struct dl_info_req_t dl_info_req_t;
|
|
/* DL_INFO_ACK, M_PCPROTO type*/
|
|
struct dl_info_ack_t {
|
|
UInt32 dl_primitive; /* set to DL_INFO_ACK */
|
|
UInt32 dl_max_sdu; /* Max bytes in a DLSDU */
|
|
UInt32 dl_min_sdu; /* Min bytes in a DLSDU */
|
|
UInt32 dl_addr_length; /* length of DLSAP address */
|
|
UInt32 dl_mac_type; /* type of medium supported*/
|
|
UInt32 dl_reserved; /* value set to zero */
|
|
UInt32 dl_current_state; /* state of DLPI interface */
|
|
SInt32 dl_sap_length; /* current length of SAP part of dlsap address */
|
|
UInt32 dl_service_mode; /* CO, CL or ACL */
|
|
UInt32 dl_qos_length; /* length of qos values */
|
|
UInt32 dl_qos_offset; /* offset from beg. of block*/
|
|
UInt32 dl_qos_range_length; /* available range of qos */
|
|
UInt32 dl_qos_range_offset; /* offset from beg. of block*/
|
|
UInt32 dl_provider_style; /* style1 or style2 */
|
|
UInt32 dl_addr_offset; /* offset of the dlsap addr */
|
|
UInt32 dl_version; /* version number */
|
|
UInt32 dl_brdcst_addr_length; /* length of broadcast addr */
|
|
UInt32 dl_brdcst_addr_offset; /* offset from beg. of block*/
|
|
UInt32 dl_growth; /* set to zero */
|
|
};
|
|
typedef struct dl_info_ack_t dl_info_ack_t;
|
|
/* DL_ATTACH_REQ, M_PROTO type*/
|
|
struct dl_attach_req_t {
|
|
UInt32 dl_primitive; /* set to DL_ATTACH_REQ*/
|
|
UInt32 dl_ppa; /* id of the PPA */
|
|
};
|
|
typedef struct dl_attach_req_t dl_attach_req_t;
|
|
/* DL_DETACH_REQ, M_PROTO type*/
|
|
struct dl_detach_req_t {
|
|
UInt32 dl_primitive; /* set to DL_DETACH_REQ */
|
|
};
|
|
typedef struct dl_detach_req_t dl_detach_req_t;
|
|
/* DL_BIND_REQ, M_PROTO type*/
|
|
struct dl_bind_req_t {
|
|
UInt32 dl_primitive; /* set to DL_BIND_REQ */
|
|
UInt32 dl_sap; /* info to identify dlsap addr*/
|
|
UInt32 dl_max_conind; /* max # of outstanding con_ind*/
|
|
UInt16 dl_service_mode; /* CO, CL or ACL */
|
|
UInt16 dl_conn_mgmt; /* if non-zero, is con-mgmt stream*/
|
|
UInt32 dl_xidtest_flg; /* if set to 1 indicates automatic initiation of test and xid frames */
|
|
};
|
|
typedef struct dl_bind_req_t dl_bind_req_t;
|
|
/* DL_BIND_ACK, M_PCPROTO type*/
|
|
struct dl_bind_ack_t {
|
|
UInt32 dl_primitive; /* DL_BIND_ACK */
|
|
UInt32 dl_sap; /* DLSAP addr info */
|
|
UInt32 dl_addr_length; /* length of complete DLSAP addr */
|
|
UInt32 dl_addr_offset; /* offset from beginning of M_PCPROTO*/
|
|
UInt32 dl_max_conind; /* allowed max. # of con-ind */
|
|
UInt32 dl_xidtest_flg; /* responses supported by provider*/
|
|
};
|
|
typedef struct dl_bind_ack_t dl_bind_ack_t;
|
|
/* DL_SUBS_BIND_REQ, M_PROTO type*/
|
|
struct dl_subs_bind_req_t {
|
|
UInt32 dl_primitive; /* DL_SUBS_BIND_REQ */
|
|
UInt32 dl_subs_sap_offset; /* offset of subs_sap */
|
|
UInt32 dl_subs_sap_length; /* length of subs_sap */
|
|
UInt32 dl_subs_bind_class; /* peer or hierarchical */
|
|
};
|
|
typedef struct dl_subs_bind_req_t dl_subs_bind_req_t;
|
|
/* DL_SUBS_BIND_ACK, M_PCPROTO type*/
|
|
struct dl_subs_bind_ack_t {
|
|
UInt32 dl_primitive; /* DL_SUBS_BIND_ACK */
|
|
UInt32 dl_subs_sap_offset; /* offset of subs_sap */
|
|
UInt32 dl_subs_sap_length; /* length of subs_sap */
|
|
};
|
|
typedef struct dl_subs_bind_ack_t dl_subs_bind_ack_t;
|
|
/* DL_UNBIND_REQ, M_PROTO type*/
|
|
struct dl_unbind_req_t {
|
|
UInt32 dl_primitive; /* DL_UNBIND_REQ */
|
|
};
|
|
typedef struct dl_unbind_req_t dl_unbind_req_t;
|
|
/* DL_SUBS_UNBIND_REQ, M_PROTO type*/
|
|
struct dl_subs_unbind_req_t {
|
|
UInt32 dl_primitive; /* DL_SUBS_UNBIND_REQ */
|
|
UInt32 dl_subs_sap_offset; /* offset of subs_sap */
|
|
UInt32 dl_subs_sap_length; /* length of subs_sap */
|
|
};
|
|
typedef struct dl_subs_unbind_req_t dl_subs_unbind_req_t;
|
|
/* DL_OK_ACK, M_PCPROTO type*/
|
|
struct dl_ok_ack_t {
|
|
UInt32 dl_primitive; /* DL_OK_ACK */
|
|
UInt32 dl_correct_primitive; /* primitive being acknowledged */
|
|
};
|
|
typedef struct dl_ok_ack_t dl_ok_ack_t;
|
|
/* DL_ERROR_ACK, M_PCPROTO type*/
|
|
struct dl_error_ack_t {
|
|
UInt32 dl_primitive; /* DL_ERROR_ACK */
|
|
UInt32 dl_error_primitive; /* primitive in error */
|
|
UInt32 dl_errno; /* DLPI error code */
|
|
UInt32 dl_unix_errno; /* UNIX system error code */
|
|
};
|
|
typedef struct dl_error_ack_t dl_error_ack_t;
|
|
/* DL_ENABMULTI_REQ, M_PROTO type*/
|
|
struct dl_enabmulti_req_t {
|
|
UInt32 dl_primitive; /* DL_ENABMULTI_REQ */
|
|
UInt32 dl_addr_length; /* length of multicast address */
|
|
UInt32 dl_addr_offset; /* offset from beg. of M_PROTO block*/
|
|
};
|
|
typedef struct dl_enabmulti_req_t dl_enabmulti_req_t;
|
|
/* DL_DISABMULTI_REQ, M_PROTO type*/
|
|
struct dl_disabmulti_req_t {
|
|
UInt32 dl_primitive; /* DL_DISABMULTI_REQ */
|
|
UInt32 dl_addr_length; /* length of multicast address */
|
|
UInt32 dl_addr_offset; /* offset from beg. of M_PROTO block*/
|
|
};
|
|
typedef struct dl_disabmulti_req_t dl_disabmulti_req_t;
|
|
/* DL_PROMISCON_REQ, M_PROTO type*/
|
|
struct dl_promiscon_req_t {
|
|
UInt32 dl_primitive; /* DL_PROMISCON_REQ */
|
|
UInt32 dl_level; /* physical,SAP level or ALL multicast*/
|
|
};
|
|
typedef struct dl_promiscon_req_t dl_promiscon_req_t;
|
|
/* DL_PROMISCOFF_REQ, M_PROTO type*/
|
|
struct dl_promiscoff_req_t {
|
|
UInt32 dl_primitive; /* DL_PROMISCOFF_REQ */
|
|
UInt32 dl_level; /* Physical,SAP level or ALL multicast*/
|
|
};
|
|
typedef struct dl_promiscoff_req_t dl_promiscoff_req_t;
|
|
/* Primitives to get and set the Physical address*/
|
|
/* DL_PHYS_ADDR_REQ, M_PROTO type*/
|
|
|
|
struct dl_phys_addr_req_t {
|
|
UInt32 dl_primitive; /* DL_PHYS_ADDR_REQ */
|
|
UInt32 dl_addr_type; /* factory or current physical addr */
|
|
};
|
|
typedef struct dl_phys_addr_req_t dl_phys_addr_req_t;
|
|
/* DL_PHYS_ADDR_ACK, M_PCPROTO type*/
|
|
struct dl_phys_addr_ack_t {
|
|
UInt32 dl_primitive; /* DL_PHYS_ADDR_ACK */
|
|
UInt32 dl_addr_length; /* length of the physical addr */
|
|
UInt32 dl_addr_offset; /* offset from beg. of block */
|
|
};
|
|
typedef struct dl_phys_addr_ack_t dl_phys_addr_ack_t;
|
|
/* DL_SET_PHYS_ADDR_REQ, M_PROTO type*/
|
|
struct dl_set_phys_addr_req_t {
|
|
UInt32 dl_primitive; /* DL_SET_PHYS_ADDR_REQ */
|
|
UInt32 dl_addr_length; /* length of physical addr */
|
|
UInt32 dl_addr_offset; /* offset from beg. of block */
|
|
};
|
|
typedef struct dl_set_phys_addr_req_t dl_set_phys_addr_req_t;
|
|
/* Primitives to get statistics*/
|
|
/* DL_GET_STATISTICS_REQ, M_PROTO type*/
|
|
|
|
struct dl_get_statistics_req_t {
|
|
UInt32 dl_primitive; /* DL_GET_STATISTICS_REQ */
|
|
};
|
|
typedef struct dl_get_statistics_req_t dl_get_statistics_req_t;
|
|
/* DL_GET_STATISTICS_ACK, M_PCPROTO type*/
|
|
struct dl_get_statistics_ack_t {
|
|
UInt32 dl_primitive; /* DL_GET_STATISTICS_ACK */
|
|
UInt32 dl_stat_length; /* length of statistics structure*/
|
|
UInt32 dl_stat_offset; /* offset from beg. of block */
|
|
};
|
|
typedef struct dl_get_statistics_ack_t dl_get_statistics_ack_t;
|
|
/* CONNECTION-ORIENTED SERVICE PRIMITIVES*/
|
|
|
|
/* DL_CONNECT_REQ, M_PROTO type*/
|
|
|
|
struct dl_connect_req_t {
|
|
UInt32 dl_primitive; /* DL_CONNECT_REQ */
|
|
UInt32 dl_dest_addr_length; /* len. of dlsap addr*/
|
|
UInt32 dl_dest_addr_offset; /* offset */
|
|
UInt32 dl_qos_length; /* len. of QOS parm val*/
|
|
UInt32 dl_qos_offset; /* offset */
|
|
UInt32 dl_growth; /* set to zero */
|
|
};
|
|
typedef struct dl_connect_req_t dl_connect_req_t;
|
|
/* DL_CONNECT_IND, M_PROTO type*/
|
|
struct dl_connect_ind_t {
|
|
UInt32 dl_primitive; /* DL_CONNECT_IND */
|
|
UInt32 dl_correlation; /* provider's correlation token*/
|
|
UInt32 dl_called_addr_length; /* length of called address */
|
|
UInt32 dl_called_addr_offset; /* offset from beginning of block */
|
|
UInt32 dl_calling_addr_length; /* length of calling address */
|
|
UInt32 dl_calling_addr_offset; /* offset from beginning of block */
|
|
UInt32 dl_qos_length; /* length of qos structure */
|
|
UInt32 dl_qos_offset; /* offset from beginning of block */
|
|
UInt32 dl_growth; /* set to zero */
|
|
};
|
|
typedef struct dl_connect_ind_t dl_connect_ind_t;
|
|
/* DL_CONNECT_RES, M_PROTO type*/
|
|
struct dl_connect_res_t {
|
|
UInt32 dl_primitive; /* DL_CONNECT_RES */
|
|
UInt32 dl_correlation; /* provider's correlation token */
|
|
UInt32 dl_resp_token; /* token associated with responding stream */
|
|
UInt32 dl_qos_length; /* length of qos structure */
|
|
UInt32 dl_qos_offset; /* offset from beginning of block */
|
|
UInt32 dl_growth; /* set to zero */
|
|
};
|
|
typedef struct dl_connect_res_t dl_connect_res_t;
|
|
/* DL_CONNECT_CON, M_PROTO type*/
|
|
struct dl_connect_con_t {
|
|
UInt32 dl_primitive; /* DL_CONNECT_CON*/
|
|
UInt32 dl_resp_addr_length; /* length of responder's address */
|
|
UInt32 dl_resp_addr_offset; /* offset from beginning of block*/
|
|
UInt32 dl_qos_length; /* length of qos structure */
|
|
UInt32 dl_qos_offset; /* offset from beginning of block*/
|
|
UInt32 dl_growth; /* set to zero */
|
|
};
|
|
typedef struct dl_connect_con_t dl_connect_con_t;
|
|
/* DL_TOKEN_REQ, M_PCPROTO type*/
|
|
struct dl_token_req_t {
|
|
UInt32 dl_primitive; /* DL_TOKEN_REQ */
|
|
};
|
|
typedef struct dl_token_req_t dl_token_req_t;
|
|
/* DL_TOKEN_ACK, M_PCPROTO type*/
|
|
struct dl_token_ack_t {
|
|
UInt32 dl_primitive; /* DL_TOKEN_ACK */
|
|
UInt32 dl_token; /* Connection response token associated with the stream */
|
|
};
|
|
typedef struct dl_token_ack_t dl_token_ack_t;
|
|
/* DL_DISCONNECT_REQ, M_PROTO type*/
|
|
struct dl_disconnect_req_t {
|
|
UInt32 dl_primitive; /* DL_DISCONNECT_REQ */
|
|
UInt32 dl_reason; /*normal, abnormal, perm. or transient*/
|
|
UInt32 dl_correlation; /* association with connect_ind */
|
|
};
|
|
typedef struct dl_disconnect_req_t dl_disconnect_req_t;
|
|
/* DL_DISCONNECT_IND, M_PROTO type*/
|
|
struct dl_disconnect_ind_t {
|
|
UInt32 dl_primitive; /* DL_DISCONNECT_IND */
|
|
UInt32 dl_originator; /* USER or PROVIDER */
|
|
UInt32 dl_reason; /* permanent or transient */
|
|
UInt32 dl_correlation; /* association with connect_ind */
|
|
};
|
|
typedef struct dl_disconnect_ind_t dl_disconnect_ind_t;
|
|
/* DL_RESET_REQ, M_PROTO type*/
|
|
struct dl_reset_req_t {
|
|
UInt32 dl_primitive; /* DL_RESET_REQ */
|
|
};
|
|
typedef struct dl_reset_req_t dl_reset_req_t;
|
|
/* DL_RESET_IND, M_PROTO type*/
|
|
struct dl_reset_ind_t {
|
|
UInt32 dl_primitive; /* DL_RESET_IND */
|
|
UInt32 dl_originator; /* Provider or User */
|
|
UInt32 dl_reason; /* flow control, link error or resynch*/
|
|
};
|
|
typedef struct dl_reset_ind_t dl_reset_ind_t;
|
|
/* DL_RESET_RES, M_PROTO type*/
|
|
struct dl_reset_res_t {
|
|
UInt32 dl_primitive; /* DL_RESET_RES */
|
|
};
|
|
typedef struct dl_reset_res_t dl_reset_res_t;
|
|
/* DL_RESET_CON, M_PROTO type*/
|
|
struct dl_reset_con_t {
|
|
UInt32 dl_primitive; /* DL_RESET_CON */
|
|
};
|
|
typedef struct dl_reset_con_t dl_reset_con_t;
|
|
/* CONNECTIONLESS SERVICE PRIMITIVES*/
|
|
/* DL_UNITDATA_REQ, M_PROTO type, with M_DATA block(s)*/
|
|
|
|
struct dl_unitdata_req_t {
|
|
UInt32 dl_primitive; /* DL_UNITDATA_REQ */
|
|
UInt32 dl_dest_addr_length; /* DLSAP length of dest. user */
|
|
UInt32 dl_dest_addr_offset; /* offset from beg. of block */
|
|
dl_priority_t dl_priority; /* priority value */
|
|
};
|
|
typedef struct dl_unitdata_req_t dl_unitdata_req_t;
|
|
/* DL_UNITDATA_IND, M_PROTO type, with M_DATA block(s)*/
|
|
struct dl_unitdata_ind_t {
|
|
UInt32 dl_primitive; /* DL_UNITDATA_IND */
|
|
UInt32 dl_dest_addr_length; /* DLSAP length of dest. user */
|
|
UInt32 dl_dest_addr_offset; /* offset from beg. of block */
|
|
UInt32 dl_src_addr_length; /* DLSAP addr length of sending user*/
|
|
UInt32 dl_src_addr_offset; /* offset from beg. of block */
|
|
UInt32 dl_group_address; /* set to one if multicast/broadcast*/
|
|
};
|
|
typedef struct dl_unitdata_ind_t dl_unitdata_ind_t;
|
|
/*
|
|
DL_UDERROR_IND, M_PROTO type
|
|
(or M_PCPROTO type if LLI-based provider)
|
|
*/
|
|
struct dl_uderror_ind_t {
|
|
UInt32 dl_primitive; /* DL_UDERROR_IND */
|
|
UInt32 dl_dest_addr_length; /* Destination DLSAP */
|
|
UInt32 dl_dest_addr_offset; /* Offset from beg. of block */
|
|
UInt32 dl_unix_errno; /* unix system error code*/
|
|
UInt32 dl_errno; /* DLPI error code */
|
|
};
|
|
typedef struct dl_uderror_ind_t dl_uderror_ind_t;
|
|
/* DL_UDQOS_REQ, M_PROTO type*/
|
|
struct dl_udqos_req_t {
|
|
UInt32 dl_primitive; /* DL_UDQOS_REQ */
|
|
UInt32 dl_qos_length; /* length in bytes of requested qos*/
|
|
UInt32 dl_qos_offset; /* offset from beg. of block */
|
|
};
|
|
typedef struct dl_udqos_req_t dl_udqos_req_t;
|
|
/* Primitives to handle XID and TEST operations*/
|
|
/* DL_TEST_REQ, M_PROTO type*/
|
|
|
|
struct dl_test_req_t {
|
|
UInt32 dl_primitive; /* DL_TEST_REQ */
|
|
UInt32 dl_flag; /* poll/final */
|
|
UInt32 dl_dest_addr_length; /* DLSAP length of dest. user */
|
|
UInt32 dl_dest_addr_offset; /* offset from beg. of block */
|
|
};
|
|
typedef struct dl_test_req_t dl_test_req_t;
|
|
/* DL_TEST_IND, M_PROTO type*/
|
|
struct dl_test_ind_t {
|
|
UInt32 dl_primitive; /* DL_TEST_IND */
|
|
UInt32 dl_flag; /* poll/final */
|
|
UInt32 dl_dest_addr_length; /* dlsap length of dest. user */
|
|
UInt32 dl_dest_addr_offset; /* offset from beg. of block */
|
|
UInt32 dl_src_addr_length; /* dlsap length of source user */
|
|
UInt32 dl_src_addr_offset; /* offset from beg. of block */
|
|
};
|
|
typedef struct dl_test_ind_t dl_test_ind_t;
|
|
/* DL_TEST_RES, M_PROTO type*/
|
|
struct dl_test_res_t {
|
|
UInt32 dl_primitive; /* DL_TEST_RES */
|
|
UInt32 dl_flag; /* poll/final */
|
|
UInt32 dl_dest_addr_length; /* DLSAP length of dest. user */
|
|
UInt32 dl_dest_addr_offset; /* offset from beg. of block */
|
|
};
|
|
typedef struct dl_test_res_t dl_test_res_t;
|
|
/* DL_TEST_CON, M_PROTO type*/
|
|
struct dl_test_con_t {
|
|
UInt32 dl_primitive; /* DL_TEST_CON */
|
|
UInt32 dl_flag; /* poll/final */
|
|
UInt32 dl_dest_addr_length; /* dlsap length of dest. user */
|
|
UInt32 dl_dest_addr_offset; /* offset from beg. of block */
|
|
UInt32 dl_src_addr_length; /* dlsap length of source user */
|
|
UInt32 dl_src_addr_offset; /* offset from beg. of block */
|
|
};
|
|
typedef struct dl_test_con_t dl_test_con_t;
|
|
/* DL_XID_REQ, M_PROTO type*/
|
|
struct dl_xid_req_t {
|
|
UInt32 dl_primitive; /* DL_XID_REQ */
|
|
UInt32 dl_flag; /* poll/final */
|
|
UInt32 dl_dest_addr_length; /* dlsap length of dest. user */
|
|
UInt32 dl_dest_addr_offset; /* offset from beg. of block */
|
|
};
|
|
typedef struct dl_xid_req_t dl_xid_req_t;
|
|
/* DL_XID_IND, M_PROTO type*/
|
|
struct dl_xid_ind_t {
|
|
UInt32 dl_primitive; /* DL_XID_IND */
|
|
UInt32 dl_flag; /* poll/final */
|
|
UInt32 dl_dest_addr_length; /* dlsap length of dest. user */
|
|
UInt32 dl_dest_addr_offset; /* offset from beg. of block */
|
|
UInt32 dl_src_addr_length; /* dlsap length of source user */
|
|
UInt32 dl_src_addr_offset; /* offset from beg. of block */
|
|
};
|
|
typedef struct dl_xid_ind_t dl_xid_ind_t;
|
|
/* DL_XID_RES, M_PROTO type*/
|
|
struct dl_xid_res_t {
|
|
UInt32 dl_primitive; /* DL_XID_RES */
|
|
UInt32 dl_flag; /* poll/final */
|
|
UInt32 dl_dest_addr_length; /* DLSAP length of dest. user */
|
|
UInt32 dl_dest_addr_offset; /* offset from beg. of block */
|
|
};
|
|
typedef struct dl_xid_res_t dl_xid_res_t;
|
|
/* DL_XID_CON, M_PROTO type*/
|
|
struct dl_xid_con_t {
|
|
UInt32 dl_primitive; /* DL_XID_CON */
|
|
UInt32 dl_flag; /* poll/final */
|
|
UInt32 dl_dest_addr_length; /* dlsap length of dest. user */
|
|
UInt32 dl_dest_addr_offset; /* offset from beg. of block */
|
|
UInt32 dl_src_addr_length; /* dlsap length of source user */
|
|
UInt32 dl_src_addr_offset; /* offset from beg. of block */
|
|
};
|
|
typedef struct dl_xid_con_t dl_xid_con_t;
|
|
/* ACKNOWLEDGED CONNECTIONLESS SERVICE PRIMITIVES*/
|
|
|
|
/* DL_DATA_ACK_REQ, M_PROTO type*/
|
|
|
|
struct dl_data_ack_req_t {
|
|
UInt32 dl_primitive; /* DL_DATA_ACK_REQ */
|
|
UInt32 dl_correlation; /* User's correlation token */
|
|
UInt32 dl_dest_addr_length; /* length of destination addr */
|
|
UInt32 dl_dest_addr_offset; /* offset from beginning of block */
|
|
UInt32 dl_src_addr_length; /* length of source address */
|
|
UInt32 dl_src_addr_offset; /* offset from beginning of block */
|
|
UInt32 dl_priority; /* priority */
|
|
UInt32 dl_service_class; /* DL_RQST_RSP or DL_RQST_NORSP */
|
|
};
|
|
typedef struct dl_data_ack_req_t dl_data_ack_req_t;
|
|
/* DL_DATA_ACK_IND, M_PROTO type*/
|
|
struct dl_data_ack_ind_t {
|
|
UInt32 dl_primitive; /* DL_DATA_ACK_IND */
|
|
UInt32 dl_dest_addr_length; /* length of destination addr */
|
|
UInt32 dl_dest_addr_offset; /* offset from beginning of block */
|
|
UInt32 dl_src_addr_length; /* length of source address */
|
|
UInt32 dl_src_addr_offset; /* offset from beginning of block */
|
|
UInt32 dl_priority; /* priority for data unit transm. */
|
|
UInt32 dl_service_class; /* DL_RQST_RSP or DL_RQST_NORSP */
|
|
};
|
|
typedef struct dl_data_ack_ind_t dl_data_ack_ind_t;
|
|
/* DL_DATA_ACK_STATUS_IND, M_PROTO type*/
|
|
struct dl_data_ack_status_ind_t {
|
|
UInt32 dl_primitive; /* DL_DATA_ACK_STATUS_IND */
|
|
UInt32 dl_correlation; /* User's correlation token */
|
|
UInt32 dl_status; /* success or failure of previous req*/
|
|
};
|
|
typedef struct dl_data_ack_status_ind_t dl_data_ack_status_ind_t;
|
|
/* DL_REPLY_REQ, M_PROTO type*/
|
|
struct dl_reply_req_t {
|
|
UInt32 dl_primitive; /* DL_REPLY_REQ */
|
|
UInt32 dl_correlation; /* User's correlation token */
|
|
UInt32 dl_dest_addr_length; /* length of destination address */
|
|
UInt32 dl_dest_addr_offset; /* offset from beginning of block */
|
|
UInt32 dl_src_addr_length; /* source address length */
|
|
UInt32 dl_src_addr_offset; /* offset from beginning of block */
|
|
UInt32 dl_priority; /* priority for data unit transmission*/
|
|
UInt32 dl_service_class;
|
|
};
|
|
typedef struct dl_reply_req_t dl_reply_req_t;
|
|
/* DL_REPLY_IND, M_PROTO type*/
|
|
struct dl_reply_ind_t {
|
|
UInt32 dl_primitive; /* DL_REPLY_IND */
|
|
UInt32 dl_dest_addr_length; /* length of destination address */
|
|
UInt32 dl_dest_addr_offset; /* offset from beginning of block*/
|
|
UInt32 dl_src_addr_length; /* length of source address */
|
|
UInt32 dl_src_addr_offset; /* offset from beginning of block */
|
|
UInt32 dl_priority; /* priority for data unit transmission*/
|
|
UInt32 dl_service_class; /* DL_RQST_RSP or DL_RQST_NORSP */
|
|
};
|
|
typedef struct dl_reply_ind_t dl_reply_ind_t;
|
|
/* DL_REPLY_STATUS_IND, M_PROTO type*/
|
|
struct dl_reply_status_ind_t {
|
|
UInt32 dl_primitive; /* DL_REPLY_STATUS_IND */
|
|
UInt32 dl_correlation; /* User's correlation token */
|
|
UInt32 dl_status; /* success or failure of previous req*/
|
|
};
|
|
typedef struct dl_reply_status_ind_t dl_reply_status_ind_t;
|
|
/* DL_REPLY_UPDATE_REQ, M_PROTO type*/
|
|
struct dl_reply_update_req_t {
|
|
UInt32 dl_primitive; /* DL_REPLY_UPDATE_REQ */
|
|
UInt32 dl_correlation; /* user's correlation token */
|
|
UInt32 dl_src_addr_length; /* length of source address */
|
|
UInt32 dl_src_addr_offset; /* offset from beginning of block */
|
|
};
|
|
typedef struct dl_reply_update_req_t dl_reply_update_req_t;
|
|
/* DL_REPLY_UPDATE_STATUS_IND, M_PROTO type*/
|
|
struct dl_reply_update_status_ind_t {
|
|
UInt32 dl_primitive; /* DL_REPLY_UPDATE_STATUS_IND */
|
|
UInt32 dl_correlation; /* User's correlation token */
|
|
UInt32 dl_status; /* success or failure of previous req*/
|
|
};
|
|
typedef struct dl_reply_update_status_ind_t dl_reply_update_status_ind_t;
|
|
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;
|
|
enum {
|
|
DL_INFO_REQ_SIZE = sizeof(dl_info_req_t),
|
|
DL_INFO_ACK_SIZE = sizeof(dl_info_ack_t),
|
|
DL_ATTACH_REQ_SIZE = sizeof(dl_attach_req_t),
|
|
DL_DETACH_REQ_SIZE = sizeof(dl_detach_req_t),
|
|
DL_BIND_REQ_SIZE = sizeof(dl_bind_req_t),
|
|
DL_BIND_ACK_SIZE = sizeof(dl_bind_ack_t),
|
|
DL_UNBIND_REQ_SIZE = sizeof(dl_unbind_req_t),
|
|
DL_SUBS_BIND_REQ_SIZE = sizeof(dl_subs_bind_req_t),
|
|
DL_SUBS_BIND_ACK_SIZE = sizeof(dl_subs_bind_ack_t),
|
|
DL_SUBS_UNBIND_REQ_SIZE = sizeof(dl_subs_unbind_req_t),
|
|
DL_OK_ACK_SIZE = sizeof(dl_ok_ack_t),
|
|
DL_ERROR_ACK_SIZE = sizeof(dl_error_ack_t),
|
|
DL_CONNECT_REQ_SIZE = sizeof(dl_connect_req_t),
|
|
DL_CONNECT_IND_SIZE = sizeof(dl_connect_ind_t),
|
|
DL_CONNECT_RES_SIZE = sizeof(dl_connect_res_t),
|
|
DL_CONNECT_CON_SIZE = sizeof(dl_connect_con_t),
|
|
DL_TOKEN_REQ_SIZE = sizeof(dl_token_req_t),
|
|
DL_TOKEN_ACK_SIZE = sizeof(dl_token_ack_t),
|
|
DL_DISCONNECT_REQ_SIZE = sizeof(dl_disconnect_req_t),
|
|
DL_DISCONNECT_IND_SIZE = sizeof(dl_disconnect_ind_t),
|
|
DL_RESET_REQ_SIZE = sizeof(dl_reset_req_t),
|
|
DL_RESET_IND_SIZE = sizeof(dl_reset_ind_t),
|
|
DL_RESET_RES_SIZE = sizeof(dl_reset_res_t),
|
|
DL_RESET_CON_SIZE = sizeof(dl_reset_con_t),
|
|
DL_UNITDATA_REQ_SIZE = sizeof(dl_unitdata_req_t),
|
|
DL_UNITDATA_IND_SIZE = sizeof(dl_unitdata_ind_t),
|
|
DL_UDERROR_IND_SIZE = sizeof(dl_uderror_ind_t),
|
|
DL_UDQOS_REQ_SIZE = sizeof(dl_udqos_req_t),
|
|
DL_ENABMULTI_REQ_SIZE = sizeof(dl_enabmulti_req_t),
|
|
DL_DISABMULTI_REQ_SIZE = sizeof(dl_disabmulti_req_t),
|
|
DL_PROMISCON_REQ_SIZE = sizeof(dl_promiscon_req_t),
|
|
DL_PROMISCOFF_REQ_SIZE = sizeof(dl_promiscoff_req_t),
|
|
DL_PHYS_ADDR_REQ_SIZE = sizeof(dl_phys_addr_req_t),
|
|
DL_PHYS_ADDR_ACK_SIZE = sizeof(dl_phys_addr_ack_t),
|
|
DL_SET_PHYS_ADDR_REQ_SIZE = sizeof(dl_set_phys_addr_req_t),
|
|
DL_GET_STATISTICS_REQ_SIZE = sizeof(dl_get_statistics_req_t),
|
|
DL_GET_STATISTICS_ACK_SIZE = sizeof(dl_get_statistics_ack_t),
|
|
DL_XID_REQ_SIZE = sizeof(dl_xid_req_t),
|
|
DL_XID_IND_SIZE = sizeof(dl_xid_ind_t),
|
|
DL_XID_RES_SIZE = sizeof(dl_xid_res_t),
|
|
DL_XID_CON_SIZE = sizeof(dl_xid_con_t),
|
|
DL_TEST_REQ_SIZE = sizeof(dl_test_req_t),
|
|
DL_TEST_IND_SIZE = sizeof(dl_test_ind_t),
|
|
DL_TEST_RES_SIZE = sizeof(dl_test_res_t),
|
|
DL_TEST_CON_SIZE = sizeof(dl_test_con_t),
|
|
DL_DATA_ACK_REQ_SIZE = sizeof(dl_data_ack_req_t),
|
|
DL_DATA_ACK_IND_SIZE = sizeof(dl_data_ack_ind_t),
|
|
DL_DATA_ACK_STATUS_IND_SIZE = sizeof(dl_data_ack_status_ind_t),
|
|
DL_REPLY_REQ_SIZE = sizeof(dl_reply_req_t),
|
|
DL_REPLY_IND_SIZE = sizeof(dl_reply_ind_t),
|
|
DL_REPLY_STATUS_IND_SIZE = sizeof(dl_reply_status_ind_t),
|
|
DL_REPLY_UPDATE_REQ_SIZE = sizeof(dl_reply_update_req_t),
|
|
DL_REPLY_UPDATE_STATUS_IND_SIZE = sizeof(dl_reply_update_status_ind_t)
|
|
};
|
|
|
|
enum {
|
|
DL_IOC_HDR_INFO = ((MIOC_DLPI << 8) | 10) /* Fast path request */
|
|
};
|
|
|
|
/* ***** From the Mentat "modnames.h" ******/
|
|
|
|
|
|
#define MI_AFU_NAME "afu"
|
|
#define MI_AHARP_NAME "ahar"
|
|
#define MI_AHENET_NAME "ahen"
|
|
#define MI_ARP_NAME "arp"
|
|
#define MI_ARPM_NAME "arpm"
|
|
#define MI_COURMUX_NAME "courmux"
|
|
#define MI_CLONE_NAME "clone"
|
|
#define MI_DLB_NAME "dlb"
|
|
#define MI_DLM_NAME "dlm"
|
|
#define MI_DMODD_NAME "disdlpi"
|
|
#define MI_DMODT_NAME "distpi"
|
|
#define MI_DN_NAME "dn"
|
|
#define MI_DNF_NAME "dnf"
|
|
#define MI_DRVE_NAME "drve"
|
|
#define MI_ECHO_NAME "echo"
|
|
#define MI_ENXR_NAME "enxr"
|
|
#define MI_RAWIP_NAME "rawip"
|
|
#define MI_RAWIPM_NAME "rawipm"
|
|
#define MI_HAVOC_NAME "havoc"
|
|
#define MI_HAVOCM_NAME "havocm"
|
|
#define MI_IP_NAME "ip"
|
|
#define MI_IPM_NAME "ipm"
|
|
#define MI_IPX_NAME "ipx"
|
|
#define MI_LOG_NAME "log"
|
|
#define MI_MODE_NAME "mode"
|
|
#define MI_MUX_NAME "mux"
|
|
#define MI_NECHO_NAME "necho"
|
|
#define MI_NPEP_NAME "npep"
|
|
#define MI_NULS_NAME "nuls"
|
|
#define MI_NULZ_NAME "nulz"
|
|
#define MI_PASS_NAME "pass"
|
|
#define MI_PIPEMOD_NAME "pipemod"
|
|
#define MI_SAD_NAME "sad"
|
|
#define MI_SC_NAME "sc"
|
|
#define MI_SOCKMOD_NAME "sockmod"
|
|
#define MI_SPASS_NAME "spass"
|
|
#define MI_SPX_NAME "spx"
|
|
#define MI_STH_NAME "mi_sth"
|
|
#define MI_TCP_NAME "tcp"
|
|
#define MI_TCPM_NAME "tcpm"
|
|
#define MI_TIMOD_NAME "timod"
|
|
#define MI_TIRDWR_NAME "tirdwr"
|
|
#define MI_TMOD_NAME "tmod"
|
|
#define MI_TMUX_NAME "tmux"
|
|
#define MI_TPIT_NAME "tpit"
|
|
#define MI_TRSR_NAME "trsr"
|
|
#define MI_TRXR_NAME "trxr"
|
|
#define MI_UDP_NAME "udp"
|
|
#define MI_UDPM_NAME "udpm"
|
|
#define MI_WELD_NAME "mi_weld"
|
|
#define MI_XDG_NAME "xdg"
|
|
#define MI_XECHO_NAME "xecho"
|
|
#define MI_XF_NAME "xf"
|
|
#define MI_XFIPX_NAME "xfipx"
|
|
#define MI_XFXNS_NAME "xfxns"
|
|
#define MI_XPE_NAME "xpe"
|
|
#define MI_XS_NAME "xs"
|
|
#define MI_XTINDG_NAME "xtindg"
|
|
#define MI_XTINVC_NAME "xtinvc"
|
|
#define MI_XTM_NAME "xtm"
|
|
#define MI_XTMIP_NAME "xtmip"
|
|
|
|
#define MI_AFU_DEVICE "/dev/afu"
|
|
#define MI_ARP_DEVICE "/dev/arp"
|
|
#define MI_COURMUX_DEVICE "/dev/courmux"
|
|
#define MI_CLONE_DEVICE "/dev/clone"
|
|
#define MI_DLB_DEVICE "/dev/dlb"
|
|
#define MI_DN_DEVICE "/dev/dn"
|
|
#define MI_DNF_DEVICE "/dev/dnf"
|
|
#define MI_DRVE_DEVICE "/dev/drve"
|
|
#define MI_ECHO_DEVICE "/dev/echo"
|
|
#define MI_RAWIP_DEVICE "/dev/rawip"
|
|
#define MI_HAVOC_DEVICE "/dev/havoc"
|
|
#define MI_IP_DEVICE "/dev/ip"
|
|
#define MI_IPX_DEVICE "/dev/ipx"
|
|
#define MI_LOG_DEVICE "/dev/log"
|
|
#define MI_MODE_DEVICE "/dev/mode"
|
|
#define MI_MUX_DEVICE "/dev/mux"
|
|
#define MI_NECHO_DEVICE "/dev/necho"
|
|
#define MI_NPEP_DEVICE "/dev/npep"
|
|
#define MI_NULS_DEVICE "/dev/nuls"
|
|
#define MI_NULZ_DEVICE "/dev/nulz"
|
|
#define MI_SAD_DEVICE "/dev/sad"
|
|
#define MI_SPX_DEVICE "/dev/spx"
|
|
#define MI_TCP_DEVICE "/dev/tcp"
|
|
#define MI_TMUX_DEVICE "/dev/tmux"
|
|
#define MI_TMUX0_DEVICE "/dev/tmux#0"
|
|
#define MI_TMUX1_DEVICE "/dev/tmux#1"
|
|
#define MI_TPIT_DEVICE "/dev/tpit"
|
|
#define MI_UDP_DEVICE "/dev/udp"
|
|
#define MI_XDG_DEVICE "/dev/xdg"
|
|
#define MI_XECHO_DEVICE "/dev/xecho"
|
|
#define MI_XF_DEVICE "/dev/xf"
|
|
#define MI_XPE_DEVICE "/dev/xpe"
|
|
#define MI_XS_DEVICE "/dev/xs"
|
|
#define MI_XTINDG_DEVICE "/dev/xtindg"
|
|
#define MI_XTINVC_DEVICE "/dev/xtinvc"
|
|
|
|
|
|
/* Streamtab entries */
|
|
#define MI_AFU_STREAMTAB afuinfo
|
|
#define MI_AHARP_STREAMTAB aharinfo
|
|
#define MI_AHENET_STREAMTAB aheninfo
|
|
#define MI_ARP_STREAMTAB arpinfo
|
|
#define MI_ARPM_STREAMTAB arpminfo
|
|
#define MI_COURMUX_STREAMTAB courmuxinfo
|
|
#define MI_CLONE_STREAMTAB cloneinfo
|
|
#define MI_DLB_STREAMTAB dlbinfo
|
|
#define MI_DLM_STREAMTAB dlminfo
|
|
#define MI_DMODD_STREAMTAB dmoddinfo
|
|
#define MI_DMODT_STREAMTAB dmodtinfo
|
|
#define MI_DN_STREAMTAB dninfo
|
|
#define MI_DNF_STREAMTAB dnfinfo
|
|
#define MI_DRVE_STREAMTAB drveinfo
|
|
#define MI_ECHO_STREAMTAB echoinfo
|
|
#define MI_ENXR_STREAMTAB enxrinfo
|
|
#define MI_HAVOC_STREAMTAB hvcinfo
|
|
#define MI_HAVOCM_STREAMTAB hvcminfo
|
|
#define MI_IP_STREAMTAB ipinfo
|
|
#define MI_IPM_STREAMTAB ipminfo
|
|
#define MI_IPX_STREAMTAB ipxinfo
|
|
#define MI_LOG_STREAMTAB loginfo
|
|
#define MI_MODE_STREAMTAB modeinfo
|
|
#define MI_MUX_STREAMTAB muxinfo
|
|
#define MI_NECHO_STREAMTAB nechoinfo
|
|
#define MI_NPEP_STREAMTAB npepinfo
|
|
#define MI_NULS_STREAMTAB nulsinfo
|
|
#define MI_NULZ_STREAMTAB nulzinfo
|
|
#define MI_PASS_STREAMTAB passinfo
|
|
#define MI_PIPEMOD_STREAMTAB pmodinfo
|
|
#define MI_RAWIP_STREAMTAB rawipinfo
|
|
#define MI_RAWIPM_STREAMTAB rawipminfo
|
|
#define MI_SAD_STREAMTAB sadinfo
|
|
#define MI_SC_STREAMTAB scinfo
|
|
#define MI_SOCKMOD_STREAMTAB sockmodinfo
|
|
#define MI_SPASS_STREAMTAB spassinfo
|
|
#define MI_SPX_STREAMTAB spxinfo
|
|
#define MI_STH_STREAMTAB mi_sthinfo
|
|
#define MI_TCP_STREAMTAB tcpinfo
|
|
#define MI_TCPM_STREAMTAB tcpminfo
|
|
#define MI_TIMOD_STREAMTAB timodinfo
|
|
#define MI_TIRDWR_STREAMTAB tirdwrinfo
|
|
#define MI_TMOD_STREAMTAB tmodinfo
|
|
#define MI_TMUX_STREAMTAB tmuxinfo
|
|
#define MI_TPIT_STREAMTAB tpitinfo
|
|
#define MI_TRSR_STREAMTAB trsrinfo
|
|
#define MI_TRXR_STREAMTAB trxrinfo
|
|
#define MI_UDP_STREAMTAB udpinfo
|
|
#define MI_UDPM_STREAMTAB udpminfo
|
|
#define MI_WELD_STREAMTAB mi_weldinfo
|
|
#define MI_XDG_STREAMTAB xdginfo
|
|
#define MI_XECHO_STREAMTAB xechoinfo
|
|
#define MI_XF_STREAMTAB xfinfo
|
|
#define MI_XFIPX_STREAMTAB xfipxinfo
|
|
#define MI_XFXNS_STREAMTAB xfxnsinfo
|
|
#define MI_XPE_STREAMTAB xpeinfo
|
|
#define MI_XS_STREAMTAB xsinfo
|
|
#define MI_XTINDG_STREAMTAB xtindginfo
|
|
#define MI_XTINVC_STREAMTAB xtinvcinfo
|
|
#define MI_XTM_STREAMTAB xtminfo
|
|
#define MI_XTMIP_STREAMTAB xtmipinfo
|
|
|
|
|
|
#define MI_AFU_DEVFLAG afudevflag
|
|
#define MI_AHARP_DEVFLAG ahardevflag
|
|
#define MI_AHENET_DEVFLAG ahendevflag
|
|
#define MI_ARP_DEVFLAG arpdevflag
|
|
#define MI_ARPM_DEVFLAG arpmdevflag
|
|
#define MI_COURMUX_DEVFLAG courmuxdevflag
|
|
#define MI_CLONE_DEVFLAG clonedevflag
|
|
#define MI_DLB_DEVFLAG dlbdevflag
|
|
#define MI_DLM_DEVFLAG dlmdevflag
|
|
#define MI_DMODD_DEVFLAG dmodddevflag
|
|
#define MI_DMODT_DEVFLAG dmodtdevflag
|
|
#define MI_DN_DEVFLAG dndevflag
|
|
#define MI_DNF_DEVFLAG dnfdevflag
|
|
#define MI_DRVE_DEVFLAG drvedevflag
|
|
#define MI_ECHO_DEVFLAG echodevflag
|
|
#define MI_ENXR_DEVFLAG enxrdevflag
|
|
#define MI_HAVOC_DEVFLAG hvcdevflag
|
|
#define MI_HAVOCM_DEVFLAG hvcmdevflag
|
|
#define MI_IP_DEVFLAG ipdevflag
|
|
#define MI_IPM_DEVFLAG ipmdevflag
|
|
#define MI_IPX_DEVFLAG ipxdevflag
|
|
#define MI_LOG_DEVFLAG logdevflag
|
|
#define MI_MODE_DEVFLAG modedevflag
|
|
#define MI_MUX_DEVFLAG muxdevflag
|
|
#define MI_NECHO_DEVFLAG nechodevflag
|
|
#define MI_NPEP_DEVFLAG npepdevflag
|
|
#define MI_NULS_DEVFLAG nulsdevflag
|
|
#define MI_NULZ_DEVFLAG nulzdevflag
|
|
#define MI_PASS_DEVFLAG passdevflag
|
|
#define MI_PIPEMOD_DEVFLAG pipemoddevflag
|
|
#define MI_RAWIP_DEVFLAG rawipdevflag
|
|
#define MI_RAWIPM_DEVFLAG rawipmdevflag
|
|
|
|
#define MI_SAD_DEVFLAG saddevflag
|
|
#define MI_SC_DEVFLAG scdevflag
|
|
#define MI_SOCKMOD_DEVFLAG sockmoddevflag
|
|
#define MI_SPASS_DEVFLAG spassdevflag
|
|
#define MI_SPX_DEVFLAG spxdevflag
|
|
#define MI_TCP_DEVFLAG tcpdevflag
|
|
#define MI_TCPM_DEVFLAG tcpmdevflag
|
|
#define MI_TIMOD_DEVFLAG timoddevflag
|
|
#define MI_TIRDWR_DEVFLAG tirdwrdevflag
|
|
#define MI_TMOD_DEVFLAG tmoddevflag
|
|
#define MI_TMUX_DEVFLAG tmuxdevflag
|
|
#define MI_TPIT_DEVFLAG tpitdevflag
|
|
#define MI_TRSR_DEVFLAG trsrdevflag
|
|
#define MI_TRXR_DEVFLAG trxrdevflag
|
|
#define MI_UDP_DEVFLAG udpdevflag
|
|
#define MI_UDPM_DEVFLAG udpmdevflag
|
|
#define MI_XDG_DEVFLAG xdgdevflag
|
|
#define MI_XECHO_DEVFLAG xechodevflag
|
|
#define MI_XF_DEVFLAG xfdevflag
|
|
#define MI_XFIPX_DEVFLAG xfipxdevflag
|
|
#define MI_XFXNS_DEVFLAG xfxnsdevflag
|
|
#define MI_XPE_DEVFLAG xpedevflag
|
|
#define MI_XS_DEVFLAG xsdevflag
|
|
#define MI_XTINDG_DEVFLAG xtindgdevflag
|
|
#define MI_XTINVC_DEVFLAG xtinvcdevflag
|
|
#define MI_XTM_DEVFLAG xtmdevflag
|
|
#define MI_XTMIP_DEVFLAG xtmipdevflag
|
|
|
|
#define MI_AFU_SQLVL SQLVL_QUEUEPAIR
|
|
#define MI_AHARP_SQLVL SQLVL_QUEUE
|
|
#define MI_AHENET_SQLVL SQLVL_QUEUE
|
|
#define MI_ARP_SQLVL SQLVL_MODULE
|
|
#define MI_ARPM_SQLVL SQLVL_MODULE
|
|
#define MI_COURMUX_SQLVL SQLVL_MODULE
|
|
#define MI_CLONE_SQLVL SQLVL_MODULE
|
|
#define MI_DLB_SQLVL SQLVL_QUEUE
|
|
#define MI_DLM_SQLVL SQLVL_QUEUE
|
|
#define MI_DMODD_SQLVL SQLVL_QUEUE
|
|
#define MI_DMODT_SQLVL SQLVL_QUEUE
|
|
#define MI_DN_SQLVL SQLVL_QUEUE
|
|
#define MI_DNF_SQLVL SQLVL_QUEUE
|
|
#define MI_DRVE_SQLVL SQLVL_QUEUEPAIR
|
|
#define MI_ECHO_SQLVL SQLVL_QUEUE
|
|
#define MI_ENXR_SQLVL SQLVL_QUEUE
|
|
#define MI_RAWIP_SQLVL SQLVL_QUEUE
|
|
#define MI_RAWIPM_SQLVL SQLVL_QUEUE
|
|
#define MI_HAVOC_SQLVL SQLVL_QUEUE
|
|
#define MI_HAVOCM_SQLVL SQLVL_QUEUE
|
|
#define MI_IP_SQLVL SQLVL_QUEUEPAIR
|
|
#define MI_IPM_SQLVL SQLVL_QUEUEPAIR
|
|
#define MI_IPX_SQLVL SQLVL_QUEUE
|
|
#define MI_LOG_SQLVL SQLVL_MODULE
|
|
#define MI_MODE_SQLVL SQLVL_QUEUEPAIR
|
|
#define MI_MUX_SQLVL SQLVL_MODULE
|
|
#define MI_NECHO_SQLVL SQLVL_QUEUE
|
|
|
|
#define MI_NPEP_SQLVL SQLVL_QUEUE
|
|
#define MI_NULS_SQLVL SQLVL_QUEUE
|
|
#define MI_NULZ_SQLVL SQLVL_QUEUE
|
|
#define MI_PASS_SQLVL SQLVL_QUEUE
|
|
#define MI_PIPEMOD_SQLVL SQLVL_QUEUE
|
|
|
|
#define MI_SAD_SQLVL SQLVL_MODULE
|
|
#define MI_SC_SQLVL SQLVL_QUEUE
|
|
#define MI_SOCKMOD_SQLVL SQLVL_QUEUEPAIR
|
|
#define MI_SPASS_SQLVL SQLVL_QUEUE
|
|
#define MI_SPX_SQLVL SQLVL_QUEUE
|
|
#define MI_TCP_SQLVL SQLVL_QUEUEPAIR
|
|
#define MI_TCPM_SQLVL SQLVL_QUEUEPAIR
|
|
#define MI_TIMOD_SQLVL SQLVL_QUEUEPAIR
|
|
#define MI_TIRDWR_SQLVL SQLVL_QUEUE
|
|
#define MI_TMOD_SQLVL SQLVL_QUEUEPAIR
|
|
#define MI_TMUX_SQLVL SQLVL_MODULE
|
|
#define MI_TPIT_SQLVL SQLVL_MODULE
|
|
#define MI_TRSR_SQLVL SQLVL_MODULE
|
|
#define MI_TRXR_SQLVL SQLVL_QUEUE
|
|
#define MI_UDP_SQLVL SQLVL_QUEUE
|
|
#define MI_UDPM_SQLVL SQLVL_QUEUE
|
|
#define MI_XDG_SQLVL SQLVL_QUEUE
|
|
#define MI_XECHO_SQLVL SQLVL_QUEUE
|
|
#define MI_XF_SQLVL SQLVL_MODULE
|
|
#define MI_XFIPX_SQLVL SQLVL_MODULE
|
|
#define MI_XFXNS_SQLVL SQLVL_MODULE
|
|
#define MI_XPE_SQLVL SQLVL_QUEUE
|
|
#define MI_XS_SQLVL SQLVL_QUEUEPAIR
|
|
#define MI_XTINDG_SQLVL SQLVL_QUEUEPAIR
|
|
#define MI_XTINVC_SQLVL SQLVL_QUEUEPAIR
|
|
#define MI_XTM_SQLVL SQLVL_QUEUEPAIR
|
|
#define MI_XTMIP_SQLVL SQLVL_QUEUEPAIR
|
|
/* ***** Raw Streams ******/
|
|
|
|
|
|
/*
|
|
Flags used in the fType field of OTReadInfo for functions.
|
|
I've removed the terse and confusing comments in this header
|
|
file. For a full description, read "Open Transport Advanced
|
|
Client Programming".
|
|
*/
|
|
|
|
enum {
|
|
kOTNoMessagesAvailable = (unsigned long)0xFFFFFFFF,
|
|
kOTAnyMsgType = (unsigned long)0xFFFFFFFE,
|
|
kOTDataMsgTypes = (unsigned long)0xFFFFFFFC,
|
|
kOTMProtoMsgTypes = (unsigned long)0xFFFFFFFB,
|
|
kOTOnlyMProtoMsgTypes = (unsigned long)0xFFFFFFFA
|
|
};
|
|
|
|
#if !OTKERNEL
|
|
/* StreamRef is an opaque reference to a raw stream.*/
|
|
|
|
typedef struct OpaqueStreamRef* StreamRef;
|
|
#define kOTInvalidStreamRef ((StreamRef)0L)
|
|
/* PollRef structure is used with the OTStreamPoll function.*/
|
|
struct PollRef {
|
|
SInt32 filler; /* holds a file descriptor an a UNIX system, replaced by ref (at end of structure) under OT*/
|
|
SInt16 events;
|
|
SInt16 revents;
|
|
StreamRef ref;
|
|
};
|
|
typedef struct PollRef PollRef;
|
|
|
|
/* Poll masks for use with OTStreamPoll: */
|
|
|
|
#define POLLIN 0x001 /* A non-priority message is available */
|
|
#define POLLPRI 0x002 /* A high priority message is available */
|
|
#define POLLOUT 0x004 /* The stream is writable for non-priority messages */
|
|
#define POLLERR 0x008 /* A error message has arrived */
|
|
#define POLLHUP 0x010 /* A hangup has occurred */
|
|
#define POLLNVAL 0x020 /* This fd is bogus */
|
|
#define POLLRDNORM 0x040 /* A non-priority message is available */
|
|
#define POLLRDBAND 0x080 /* A priority message (band > 0) message is available */
|
|
#define POLLWRNORM 0x100 /* Same as POLLOUT */
|
|
#define POLLWRBAND 0x200 /* A priority band exists and is writable */
|
|
#define POLLMSG 0x400 /* A signal message has reached the front of the queue */
|
|
|
|
/* OTReadInfo structure is used with the various functions that read and peek at the stream head.*/
|
|
|
|
struct OTReadInfo {
|
|
UInt32 fType;
|
|
OTCommand fCommand;
|
|
UInt32 fFiller; /* For compatibility with OT 1.0 and 1.1 */
|
|
ByteCount fBytes;
|
|
OSStatus fError;
|
|
};
|
|
typedef struct OTReadInfo OTReadInfo;
|
|
/* Opening and closing raw streams*/
|
|
#if CALL_NOT_IN_CARBON
|
|
/*
|
|
* OTStreamOpen()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( StreamRef )
|
|
OTStreamOpen(
|
|
const char * name,
|
|
OTOpenFlags oFlags,
|
|
OSStatus * errPtr);
|
|
|
|
|
|
/*
|
|
* OTAsyncStreamOpen()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( OSStatus )
|
|
OTAsyncStreamOpen(
|
|
const char * name,
|
|
OTOpenFlags oFlags,
|
|
OTNotifyUPP proc,
|
|
void * contextPtr);
|
|
|
|
|
|
/*
|
|
* OTCreateStream()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( StreamRef )
|
|
OTCreateStream(
|
|
OTConfigurationRef cfig,
|
|
OTOpenFlags oFlags,
|
|
OSStatus * errPtr);
|
|
|
|
|
|
/*
|
|
* OTAsyncCreateStream()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( OSStatus )
|
|
OTAsyncCreateStream(
|
|
OTConfigurationRef cfig,
|
|
OTOpenFlags oFlags,
|
|
OTNotifyUPP proc,
|
|
void * contextPtr);
|
|
|
|
|
|
/*
|
|
* OTStreamClose()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( OSStatus )
|
|
OTStreamClose(StreamRef strm);
|
|
|
|
|
|
/* Polling a stream for activity*/
|
|
|
|
/*
|
|
* OTStreamPoll()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( OTResult )
|
|
OTStreamPoll(
|
|
PollRef * fds,
|
|
UInt32 nfds,
|
|
OTTimeout timeout);
|
|
|
|
|
|
/*
|
|
* OTAsyncStreamPoll()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( OTResult )
|
|
OTAsyncStreamPoll(
|
|
PollRef * fds,
|
|
UInt32 nfds,
|
|
OTTimeout timeout,
|
|
OTNotifyUPP proc,
|
|
void * contextPtr);
|
|
|
|
|
|
/* Classic UNIX file descriptor operations*/
|
|
|
|
/*
|
|
* OTStreamRead()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( OTResult )
|
|
OTStreamRead(
|
|
StreamRef strm,
|
|
void * buf,
|
|
OTByteCount len);
|
|
|
|
|
|
/*
|
|
* OTStreamWrite()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( OTResult )
|
|
OTStreamWrite(
|
|
StreamRef strm,
|
|
void * buf,
|
|
OTByteCount len);
|
|
|
|
|
|
/*
|
|
* OTStreamIoctl()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( OTResult )
|
|
OTStreamIoctl(
|
|
StreamRef strm,
|
|
UInt32 cmd,
|
|
void * data);
|
|
|
|
|
|
/*
|
|
* OTStreamPipe()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( OTResult )
|
|
OTStreamPipe(StreamRef streamsToPipe[]);
|
|
|
|
|
|
/* there can be only 2!*/
|
|
/* Notifiers and modes of operation*/
|
|
/*
|
|
* OTStreamInstallNotifier()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( OSStatus )
|
|
OTStreamInstallNotifier(
|
|
StreamRef strm,
|
|
OTNotifyUPP proc,
|
|
void * contextPtr);
|
|
|
|
|
|
/*
|
|
* OTStreamRemoveNotifier()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( void )
|
|
OTStreamRemoveNotifier(StreamRef strm);
|
|
|
|
|
|
/*
|
|
* OTStreamUseSyncIdleEvents()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( OSStatus )
|
|
OTStreamUseSyncIdleEvents(
|
|
StreamRef strm,
|
|
Boolean useEvents);
|
|
|
|
|
|
/*
|
|
* OTStreamSetBlocking()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( void )
|
|
OTStreamSetBlocking(StreamRef strm);
|
|
|
|
|
|
/*
|
|
* OTStreamSetNonBlocking()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( void )
|
|
OTStreamSetNonBlocking(StreamRef strm);
|
|
|
|
|
|
/*
|
|
* OTStreamIsBlocking()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( Boolean )
|
|
OTStreamIsBlocking(StreamRef strm);
|
|
|
|
|
|
/*
|
|
* OTStreamSetSynchronous()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( void )
|
|
OTStreamSetSynchronous(StreamRef strm);
|
|
|
|
|
|
/*
|
|
* OTStreamSetAsynchronous()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( void )
|
|
OTStreamSetAsynchronous(StreamRef strm);
|
|
|
|
|
|
/*
|
|
* OTStreamIsSynchronous()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( Boolean )
|
|
OTStreamIsSynchronous(StreamRef strm);
|
|
|
|
|
|
/* STREAMS primitives*/
|
|
|
|
/*
|
|
* OTStreamGetMessage()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( OTResult )
|
|
OTStreamGetMessage(
|
|
StreamRef strm,
|
|
strbuf * ctlbuf,
|
|
strbuf * databuf,
|
|
OTFlags * flags);
|
|
|
|
|
|
/*
|
|
* OTStreamGetPriorityMessage()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( OTResult )
|
|
OTStreamGetPriorityMessage(
|
|
StreamRef strm,
|
|
strbuf * ctlbuf,
|
|
strbuf * databuf,
|
|
OTBand * band,
|
|
OTFlags * flags);
|
|
|
|
|
|
/*
|
|
* OTStreamPutMessage()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( OSStatus )
|
|
OTStreamPutMessage(
|
|
StreamRef strm,
|
|
const strbuf * ctlbuf,
|
|
const strbuf * databuf,
|
|
OTFlags flags);
|
|
|
|
|
|
/*
|
|
* OTStreamPutPriorityMessage()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( OSStatus )
|
|
OTStreamPutPriorityMessage(
|
|
StreamRef strm,
|
|
const strbuf * ctlbuf,
|
|
const strbuf * databuf,
|
|
OTBand band,
|
|
OTFlags flags);
|
|
|
|
|
|
/* Miscellaneous stuff*/
|
|
|
|
/*
|
|
* OTStreamSetControlMask()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( void )
|
|
OTStreamSetControlMask(
|
|
StreamRef strm,
|
|
UInt32 mask,
|
|
Boolean setClear);
|
|
|
|
|
|
/*
|
|
Opening endpoints and mappers on a Stream - these calls are synchronous, and may
|
|
only be used at System Task time. Once the stream has been installed into a provider
|
|
or endpoint, you should not continue to use STREAMS APIs on it
|
|
*/
|
|
|
|
/*
|
|
* OTOpenProviderOnStream()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( ProviderRef )
|
|
OTOpenProviderOnStream(
|
|
StreamRef strm,
|
|
OSStatus * errPtr);
|
|
|
|
|
|
/*
|
|
* OTOpenEndpointOnStream()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( EndpointRef )
|
|
OTOpenEndpointOnStream(
|
|
StreamRef strm,
|
|
OSStatus * errPtr);
|
|
|
|
|
|
/*
|
|
To quote an earlier version of this header file:
|
|
|
|
Some functions that should only be used if
|
|
you really know what you're doing.
|
|
*/
|
|
|
|
/*
|
|
* OTRemoveStreamFromProvider()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( StreamRef )
|
|
OTRemoveStreamFromProvider(ProviderRef ref);
|
|
|
|
|
|
/*
|
|
* OTPeekMessage()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( OSStatus )
|
|
OTPeekMessage(
|
|
StreamRef strm,
|
|
OTReadInfo * readInfo);
|
|
|
|
|
|
/*
|
|
* OTReadMessage()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( OTBuffer * )
|
|
OTReadMessage(
|
|
StreamRef strm,
|
|
OTReadInfo * readInfo);
|
|
|
|
|
|
/*
|
|
* OTPutBackBuffer()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( void )
|
|
OTPutBackBuffer(
|
|
StreamRef strm,
|
|
OTBuffer * buffer);
|
|
|
|
|
|
/*
|
|
* OTPutBackPartialBuffer()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( void )
|
|
OTPutBackPartialBuffer(
|
|
StreamRef strm,
|
|
OTBufferInfo * readInfo,
|
|
OTBuffer * buffer);
|
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
#endif /* !OTKERNEL */
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
/* ***** Port Utilities ******/
|
|
#if !OTKERNEL
|
|
/*
|
|
These types and routines are used during sophisticated
|
|
port management. High-level clients may get involved
|
|
for things like request a port to be yielding, but typically
|
|
this stuff is used by protocol infrastructure.
|
|
*/
|
|
/*
|
|
OTPortCloseStruct is used when processing the kOTClosePortRequest
|
|
and kOTYieldPortRequest events.
|
|
*/
|
|
|
|
struct OTPortCloseStruct {
|
|
OTPortRef fPortRef; /* The port requested to be closed.*/
|
|
ProviderRef fTheProvider; /* The provider using the port.*/
|
|
OSStatus fDenyReason; /* Set to a negative number to deny the request*/
|
|
};
|
|
typedef struct OTPortCloseStruct OTPortCloseStruct;
|
|
/* OTClientList structure is used with the OTYieldPortRequest function.*/
|
|
struct OTClientList {
|
|
ItemCount fNumClients;
|
|
UInt8 fBuffer[4];
|
|
};
|
|
typedef struct OTClientList OTClientList;
|
|
/*
|
|
Returns a buffer containing all of the clients that refused to yield the port.
|
|
"size" is the total number of bytes @ buffer, including the fNumClients field.
|
|
*/
|
|
#if CALL_NOT_IN_CARBON
|
|
/*
|
|
* OTYieldPortRequest()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OSStatus )
|
|
OTYieldPortRequest(
|
|
ProviderRef ref,
|
|
OTPortRef portRef,
|
|
OTClientList * buffer,
|
|
OTByteCount size);
|
|
|
|
|
|
/* Send a notification to all Open Transport registered clients*/
|
|
/*
|
|
* OTNotifyAllClients()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTNotifyAllClients(
|
|
OTEventCode code,
|
|
OTResult result,
|
|
void * cookie);
|
|
|
|
|
|
/* Determine if "child" is a child port of "parent"*/
|
|
/*
|
|
* OTIsDependentPort()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
OTIsDependentPort(
|
|
OTPortRef parent,
|
|
OTPortRef child);
|
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
#endif /* !OTKERNEL */
|
|
|
|
/* ***** Timers ***** */
|
|
/*
|
|
STREAMS plug-ins code should not use these timers, instead
|
|
they should use timer messages, ie mi_timer etc.
|
|
*/
|
|
|
|
#if !OTKERNEL
|
|
|
|
typedef long OTTimerTask;
|
|
/*
|
|
Under Carbon, OTCreateTimerTask takes a client context pointer. Applications may pass NULL
|
|
after calling InitOpenTransport(kInitOTForApplicationMask, ...). Non-applications must always pass a
|
|
valid client context.
|
|
*/
|
|
/*
|
|
* OTCreateTimerTaskInContext()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: in CarbonLib 1.0 and later
|
|
* Mac OS X: in version 10.0 and later
|
|
*/
|
|
EXTERN_API( long )
|
|
OTCreateTimerTaskInContext(
|
|
OTProcessUPP upp,
|
|
void * arg,
|
|
OTClientContextPtr clientContext);
|
|
|
|
|
|
#if CALL_NOT_IN_CARBON
|
|
/*
|
|
* OTCreateTimerTask()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API( OTTimerTask )
|
|
OTCreateTimerTask(
|
|
OTProcessUPP proc,
|
|
void * arg);
|
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
/*
|
|
* OTCancelTimerTask()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: in CarbonLib 1.0 and later
|
|
* Mac OS X: in version 10.0 and later
|
|
*/
|
|
EXTERN_API( Boolean )
|
|
OTCancelTimerTask(OTTimerTask timerTask);
|
|
|
|
|
|
/*
|
|
* OTDestroyTimerTask()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: in CarbonLib 1.0 and later
|
|
* Mac OS X: in version 10.0 and later
|
|
*/
|
|
EXTERN_API( void )
|
|
OTDestroyTimerTask(OTTimerTask timerTask);
|
|
|
|
|
|
/*
|
|
* OTScheduleTimerTask()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: in CarbonLib 1.0 and later
|
|
* Mac OS X: in version 10.0 and later
|
|
*/
|
|
EXTERN_API( Boolean )
|
|
OTScheduleTimerTask(
|
|
OTTimerTask timerTask,
|
|
OTTimeout milliSeconds);
|
|
|
|
|
|
#if OTCARBONAPPLICATION
|
|
/* The following macro may be used by applications only.*/
|
|
#define OTCreateTimerTask(upp, arg) OTCreateTimerTaskInContext(upp, arg, NULL)
|
|
#endif /* OTCARBONAPPLICATION */
|
|
|
|
#endif /* !OTKERNEL */
|
|
|
|
/* ***** Miscellaneous Helpful Functions ******/
|
|
|
|
#if !OTKERNEL
|
|
/*
|
|
These routines allow you to manipulate OT's buffer structures.
|
|
If you use no-copy receives (described in "OpenTransport.h")
|
|
you will need some of these routines, and may choose to use others.
|
|
See "Open Tranport Advanced Client Programming" for documentation.
|
|
*/
|
|
/*
|
|
* OTBufferDataSize()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later
|
|
* CarbonLib: in CarbonLib 1.0 and later
|
|
* Mac OS X: in version 10.0 and later
|
|
*/
|
|
EXTERN_API_C( OTByteCount )
|
|
OTBufferDataSize(OTBuffer * buffer);
|
|
|
|
|
|
/*
|
|
* OTReadBuffer()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later
|
|
* CarbonLib: in CarbonLib 1.0 and later
|
|
* Mac OS X: in version 10.0 and later
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
OTReadBuffer(
|
|
OTBufferInfo * buffer,
|
|
void * dest,
|
|
OTByteCount * len);
|
|
|
|
|
|
/*
|
|
* OTReleaseBuffer()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later
|
|
* CarbonLib: in CarbonLib 1.0 and later
|
|
* Mac OS X: in version 10.0 and later
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTReleaseBuffer(OTBuffer * buffer);
|
|
|
|
|
|
|
|
#if CALL_NOT_IN_CARBON
|
|
/*
|
|
* StoreIntoNetbuf()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
StoreIntoNetbuf(
|
|
TNetbuf * netBuf,
|
|
void * source,
|
|
SInt32 len);
|
|
|
|
|
|
/*
|
|
* StoreMsgIntoNetbuf()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
StoreMsgIntoNetbuf(
|
|
TNetbuf * netBuf,
|
|
OTBuffer * buffer);
|
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
#endif /* !OTKERNEL */
|
|
|
|
/* ***** OTConfiguration ******/
|
|
#if CALL_NOT_IN_CARBON
|
|
#if !OTKERNEL
|
|
/*
|
|
As promised in "OpenTransport.h", here are the routines
|
|
for advanced operations on configurations.
|
|
*/
|
|
/* Manipulating a configuration*/
|
|
|
|
#if CALL_NOT_IN_CARBON
|
|
/*
|
|
* OTCfigNewConfiguration()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OTConfigurationRef )
|
|
OTCfigNewConfiguration(const char * path);
|
|
|
|
|
|
/*
|
|
* OTCfigDeleteConfiguration()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTCfigDeleteConfiguration(OTConfigurationRef cfig);
|
|
|
|
|
|
/*
|
|
* OTCfigCloneConfiguration()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OTConfigurationRef )
|
|
OTCfigCloneConfiguration(OTConfigurationRef cfig);
|
|
|
|
|
|
/*
|
|
* OTCfigPushNewSingleChild()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OTConfigurationRef )
|
|
OTCfigPushNewSingleChild(
|
|
OTConfigurationRef cfig,
|
|
const char * path,
|
|
OSStatus * errPtr);
|
|
|
|
|
|
/*
|
|
* OTCfigPushParent()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OTConfigurationRef )
|
|
OTCfigPushParent(
|
|
OTConfigurationRef cfig,
|
|
const char * path,
|
|
OSStatus * errPtr);
|
|
|
|
|
|
/*
|
|
* OTCfigPushChild()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OTConfigurationRef )
|
|
OTCfigPushChild(
|
|
OTConfigurationRef cfig,
|
|
OTItemCount index,
|
|
const char * path,
|
|
OSStatus * errPtr);
|
|
|
|
|
|
/*
|
|
* OTCfigPopChild()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OSStatus )
|
|
OTCfigPopChild(
|
|
OTConfigurationRef cfig,
|
|
OTItemCount index);
|
|
|
|
|
|
/*
|
|
* OTCfigGetChild()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OTConfigurationRef )
|
|
OTCfigGetChild(
|
|
OTConfigurationRef cfig,
|
|
OTItemCount index);
|
|
|
|
|
|
/*
|
|
* OTCfigSetPath()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OSStatus )
|
|
OTCfigSetPath(
|
|
OTConfigurationRef cfig,
|
|
const char * path);
|
|
|
|
|
|
/*
|
|
* OTCfigNewChild()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OTConfigurationRef )
|
|
OTCfigNewChild(
|
|
OTConfigurationRef cfig,
|
|
const char * path,
|
|
OSStatus * errPtr);
|
|
|
|
|
|
/*
|
|
* OTCfigAddChild()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OSStatus )
|
|
OTCfigAddChild(
|
|
OTConfigurationRef cfig,
|
|
OTConfigurationRef child);
|
|
|
|
|
|
/*
|
|
* OTCfigRemoveChild()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OTConfigurationRef )
|
|
OTCfigRemoveChild(
|
|
OTConfigurationRef cfig,
|
|
OTItemCount index);
|
|
|
|
|
|
/*
|
|
* OTCfigSetPortRef()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTCfigSetPortRef(
|
|
OTConfigurationRef cfig,
|
|
OTPortRef portRef);
|
|
|
|
|
|
/*
|
|
* OTCfigChangeProviderName()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTCfigChangeProviderName(
|
|
OTConfigurationRef cfig,
|
|
const char * name);
|
|
|
|
|
|
/* Query a configuration*/
|
|
|
|
/*
|
|
* OTCfigNumberOfChildren()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( UInt16 )
|
|
OTCfigNumberOfChildren(OTConfigurationRef cfig);
|
|
|
|
|
|
/*
|
|
* OTCfigGetParent()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OTConfigurationRef )
|
|
OTCfigGetParent(OTConfigurationRef cfig);
|
|
|
|
|
|
/*
|
|
* OTCfigGetOptionNetbuf()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( TNetbuf * )
|
|
OTCfigGetOptionNetbuf(OTConfigurationRef cfig);
|
|
|
|
|
|
/*
|
|
* OTCfigGetPortRef()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OTPortRef )
|
|
OTCfigGetPortRef(OTConfigurationRef cfig);
|
|
|
|
|
|
/*
|
|
* OTCfigGetInstallFlags()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( UInt32 )
|
|
OTCfigGetInstallFlags(OTConfigurationRef cfig);
|
|
|
|
|
|
/*
|
|
* OTCfigGetProviderName()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( const char * )
|
|
OTCfigGetProviderName(OTConfigurationRef cfig);
|
|
|
|
|
|
/*
|
|
* OTCfigIsPort()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
OTCfigIsPort(OTConfigurationRef cfig);
|
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
#endif /* !OTKERNEL */
|
|
|
|
/* ***** Configurators ******/
|
|
/*
|
|
The kOTConfiguratorInterfaceID define is what you need to add to your
|
|
export file for the "interfaceID = " clause to export a configurator
|
|
for ASLM. Similarly, kOTConfiguratorCFMTag is used for CFM-based
|
|
configurators.
|
|
*/
|
|
|
|
|
|
#define kOTConfiguratorInterfaceID kOTClientPrefix "cfigMkr"
|
|
#define kOTConfiguratorCFMTag kOTClientPrefix "cfigMkr"
|
|
|
|
#if !OTKERNEL
|
|
#ifdef __cplusplus
|
|
class TOTConfigurator;
|
|
typedef class TOTConfigurator* TOTConfiguratorRef;
|
|
#else
|
|
typedef struct TOTConfigurator TOTConfigurator;
|
|
typedef TOTConfigurator* TOTConfiguratorRef;
|
|
#endif
|
|
/*
|
|
Typedef for the OTCanConfigure function, and the enum for which pass we're doing.
|
|
The first (kOTSpecificConfigPass) is to give configurators a shot at the configuration
|
|
before we start allowing the generic configurators to get into the act.
|
|
*/
|
|
enum {
|
|
kOTSpecificConfigPass = 0,
|
|
kOTGenericConfigPass = 1
|
|
};
|
|
|
|
typedef CALLBACK_API_C( Boolean , OTCanConfigureProcPtr )(OTConfigurationRef cfig, UInt32 pass);
|
|
/* Typedef for the function to create and return a configurator object*/
|
|
typedef CALLBACK_API_C( OSStatus , OTCreateConfiguratorProcPtr )(TOTConfiguratorRef * cfigor);
|
|
/*
|
|
Typedef for the "OTSetupConfigurator" function that your configurator library must export.
|
|
The enum is for the type of configurator that it is.
|
|
*/
|
|
#define kOTSetupConfiguratorID "OTSetupConfigurator"
|
|
enum {
|
|
kOTDefaultConfigurator = 0,
|
|
kOTProtocolFamilyConfigurator = 1,
|
|
kOTLinkDriverConfigurator = 2
|
|
};
|
|
|
|
typedef CALLBACK_API_C( OSStatus , OTSetupConfiguratorProcPtr )(OTCanConfigureProcPtr *canConfigure, OTCreateConfiguratorProcPtr *createConfigurator, UInt8 *configuratorType);
|
|
/*
|
|
Procedure pointer definitions for the three key callbacks associated
|
|
with a configurator, as established by OTNewConfigurator.
|
|
*/
|
|
typedef CALLBACK_API_C( OSStatus , OTCFConfigureProcPtr )(TOTConfiguratorRef cfigor, OTConfigurationRef cfig);
|
|
typedef CALLBACK_API_C( OSStatus , OTCFCreateStreamProcPtr )(TOTConfiguratorRef cfigor, OTConfigurationRef cfig, OTOpenFlags oFlags, OTNotifyUPP proc, void *contextPtr);
|
|
typedef CALLBACK_API_C( void , OTCFHandleSystemEventProcPtr )(TOTConfiguratorRef cfigor, OTEventCode code, OTResult result, void *cookie);
|
|
/*
|
|
Determine if this instance of your configurator is the "master"
|
|
(the one that can create and destroy control streams)
|
|
*/
|
|
#if CALL_NOT_IN_CARBON
|
|
/*
|
|
* OTIsMasterConfigurator()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
OTIsMasterConfigurator(TOTConfiguratorRef cfigor);
|
|
|
|
|
|
/* Get back the userData you passed in to OTNewConfigurator*/
|
|
/*
|
|
* OTGetConfiguratorUserData()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void * )
|
|
OTGetConfiguratorUserData(TOTConfiguratorRef cfigor);
|
|
|
|
|
|
/* Create a configurator object for use by Open Transport*/
|
|
/*
|
|
* OTNewConfigurator()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( TOTConfiguratorRef )
|
|
OTNewConfigurator(
|
|
void * userData,
|
|
OTCFConfigureProcPtr configure,
|
|
OTCFCreateStreamProcPtr createStream,
|
|
OTCFHandleSystemEventProcPtr handleEvent);
|
|
|
|
|
|
/* Delete a configurator object created by OTNewConfigurator*/
|
|
/*
|
|
* OTDeleteConfigurator()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTDeleteConfigurator(TOTConfiguratorRef cfigor);
|
|
|
|
|
|
/*
|
|
A utility function to send notifications to the user - it takes care of calls
|
|
from deferred tasks
|
|
*/
|
|
/*
|
|
* OTNotifyUser()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OSStatus )
|
|
OTNotifyUser(
|
|
FSSpec * theFile,
|
|
SInt32 rsrcID,
|
|
OTItemCount index,
|
|
char * parm1,
|
|
char * parm2);
|
|
|
|
|
|
/* Call when the configurator unloads from memory*/
|
|
/*
|
|
* OTConfiguratorUnloaded()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTConfiguratorUnloaded(TOTConfiguratorRef cfigor);
|
|
|
|
|
|
/*
|
|
Call to create your control stream if you're not the master
|
|
configurator. You can also use the state machine function
|
|
OTSMCreateControlStream(OTStateMachine*, OTConfigurationRef, TOTConfiguratorRef cfigor).
|
|
*/
|
|
/*
|
|
* OTCreateControlStream()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OSStatus )
|
|
OTCreateControlStream(
|
|
OTConfigurationRef cfig,
|
|
TOTConfiguratorRef cfigor,
|
|
OTNotifyUPP proc,
|
|
void * contextPtr);
|
|
|
|
|
|
/*
|
|
A helpful function for the configurators to
|
|
be able to recursively configure the children.
|
|
*/
|
|
/*
|
|
* OTConfigureChildren()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OSStatus )
|
|
OTConfigureChildren(OTConfigurationRef cfig);
|
|
|
|
|
|
/* Allocate a bit in the system-wide control mask for streams.*/
|
|
/*
|
|
* OTNewControlMask()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( UInt32 )
|
|
OTNewControlMask(void);
|
|
|
|
|
|
/* Warning: These 2 APIs is going away*/
|
|
/*
|
|
* OTCloseProvidersByUseCount()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTCloseProvidersByUseCount(
|
|
SInt32 * useCount,
|
|
OTResult reason,
|
|
OTBooleanParam doneDeal);
|
|
|
|
|
|
/*
|
|
* OTCloseProvidersByPortRef()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTCloseProvidersByPortRef(
|
|
OTPortRef ref,
|
|
OTResult reason,
|
|
OTBooleanParam doneDeal);
|
|
|
|
|
|
/* These are the "real" APIs*/
|
|
/*
|
|
* OTCloseProviderByStream()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTCloseProviderByStream(
|
|
StreamRef ref,
|
|
OTResult reason,
|
|
OTBooleanParam doneDeal);
|
|
|
|
|
|
/*
|
|
* OTCloseMatchingProviders()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTCloseMatchingProviders(
|
|
UInt32 mask,
|
|
OTPortRef port,
|
|
OTResult reason,
|
|
OTBooleanParam doneDeal);
|
|
|
|
|
|
|
|
/* The following defines are for use in building an 'epcf' resource: */
|
|
|
|
/* Defines for fFlags field: */
|
|
#define kIsReliable 0x00000001
|
|
#define kIsNotReliable 0x00000002
|
|
#define kSupportsOrderlyRelease 0x00000004
|
|
|
|
/* Defines for fProtocolType field: */
|
|
#define kStream 0x0001
|
|
#define kUStream 0x0002
|
|
#define kTransaction 0x0004
|
|
#define kUTransaction 0x0008
|
|
#define kMapper 0x0010
|
|
#define kGenericProtocol 0x0020
|
|
|
|
/* Defines for optionType field: */
|
|
#define kBooleanOption 0
|
|
#define kUnsignedValueOption 1
|
|
#define kSignedValueOption 2
|
|
#define kHexValueOption 3
|
|
#define kPrintableStringOption 4
|
|
#define kOctetStringOption 5
|
|
|
|
/* Defines for fUpperInterface and fLowerInterface: */
|
|
#define kTPIInterface 'TPI '
|
|
#define kDLPIInterface 'DLPI'
|
|
#define kMapperInterface 'MAPR'
|
|
#define kPrivateInterface -1
|
|
#define kNoInterface 0
|
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
#endif /* !OTKERNEL */
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
/* ***** OTStateMachine ******/
|
|
#if CALL_NOT_IN_CARBON
|
|
/*
|
|
This utility set allows you to write an asynchronous chain of code that looks
|
|
somewhat like it is synchronous. This is primarily used for plumbing
|
|
streams asynchronously, especially in configurators
|
|
*/
|
|
#if !OTKERNEL
|
|
/* Alas, the state machine is only available to client code. Sorry.*/
|
|
|
|
/*
|
|
There are 12 or 8 bytes of reserved space at the front of
|
|
the OTStateMachine structure, depending on whether you're
|
|
building PowerPC or 68K code.. The OTStateMachineDataPad
|
|
type compensates for this.
|
|
*/
|
|
|
|
#if TARGET_CPU_PPC
|
|
typedef UInt8 OTStateMachineDataPad[12];
|
|
#else
|
|
typedef UInt8 OTStateMachineDataPad[8];
|
|
#endif /* TARGET_CPU_PPC */
|
|
|
|
/*
|
|
Forward define OTStateMachine so that OTStateProcPtr has
|
|
access to it.
|
|
*/
|
|
typedef struct OTStateMachine OTStateMachine;
|
|
/*
|
|
This type is is the required prototype of a state machine
|
|
entry point.
|
|
*/
|
|
typedef CALLBACK_API( void , OTStateProcPtr )(OTStateMachine * sm);
|
|
/*
|
|
This type defines a routine that the state machine will
|
|
call when the top level completes.
|
|
*/
|
|
typedef CALLBACK_API_C( void , OTSMCompleteProcPtr )(void * contextPtr);
|
|
/* And now for the state machine structure itself.*/
|
|
struct OTStateMachine {
|
|
OTStateMachineDataPad fData;
|
|
void * fCookie;
|
|
OTEventCode fCode;
|
|
OTResult fResult;
|
|
#ifdef __cplusplus
|
|
|
|
// C++ inline methods on this structure.
|
|
|
|
|
|
|
|
void* GetClientData();
|
|
|
|
Boolean CallStateProc(OTStateProcPtr proc, UInt32 state = 0);
|
|
|
|
UInt16 GetState();
|
|
|
|
void SetState(UInt32 state);
|
|
|
|
void Complete();
|
|
|
|
void Complete(OTResult result);
|
|
|
|
void Complete(OTResult result, OTEventCode code, void* contextPtr);
|
|
|
|
void CompleteToClient();
|
|
|
|
void CompleteToClient(OTResult result);
|
|
|
|
void CompleteToClient(OTResult result, OTEventCode code, void* contexPtr);
|
|
|
|
void PopCallback();
|
|
|
|
Boolean CreateStream(OTConfigurationRef cfig, OTOpenFlags flags);
|
|
|
|
Boolean OpenStream(const char* name, OTOpenFlags flags);
|
|
|
|
Boolean SendIoctl(StreamRef ref, UInt32 type, void* data);
|
|
|
|
Boolean SendIoctl(StreamRef ref, UInt32 type, long data);
|
|
|
|
Boolean PutMessage(StreamRef ref, strbuf* ctl, strbuf* data, OTFlags flags);
|
|
|
|
Boolean GetMessage(StreamRef ref, strbuf* ctl, strbuf* data, OTFlags* flagPtr);
|
|
|
|
OSStatus ReturnToCaller();
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
#define kOTSMBufferSize(callDepth) (80 + (callDepth * 8))
|
|
/*
|
|
For structSize, pass the size of your structure that you want associated with
|
|
the state machine. It can later be obtained by calling OTSMGetClientData.
|
|
For bufSize, use the kOTSMBufferSize macro, plus the size of your structure
|
|
to create a buffer on the stack. For synchronous calls, the stack buffer will
|
|
be used (unless you pass in NULL). The callDepth is the depth level of nested
|
|
calls using OTSMCallStateProc.
|
|
*/
|
|
#if CALL_NOT_IN_CARBON
|
|
/*
|
|
* OTCreateStateMachine()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OTStateMachine * )
|
|
OTCreateStateMachine(
|
|
void * buf,
|
|
OTByteCount bufSize,
|
|
OTByteCount structSize,
|
|
OTNotifyUPP proc,
|
|
void * contextPtr);
|
|
|
|
|
|
/*
|
|
* OTDestroyStateMachine()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTDestroyStateMachine(OTStateMachine * sm);
|
|
|
|
|
|
/*
|
|
OTSMCallStateProc used to take a parameter of type UInt16_p,
|
|
which was defined to be the same as UInt32. In an attempt
|
|
to reduce the number of wacky types defined by the OT
|
|
interfaces, we've changed these routines to just take a
|
|
straight UInt32. You should be warned that the current
|
|
implementation does not support values outside of the
|
|
range 0..32767. The same applies to OTSMSetState.
|
|
*/
|
|
|
|
/*
|
|
* OTSMCallStateProc()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
OTSMCallStateProc(
|
|
OTStateMachine * sm,
|
|
OTStateProcPtr proc,
|
|
UInt32 state);
|
|
|
|
|
|
/*
|
|
* OTSMGetState()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( UInt16 )
|
|
OTSMGetState(OTStateMachine * sm);
|
|
|
|
|
|
/*
|
|
* OTSMSetState()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTSMSetState(
|
|
OTStateMachine * sm,
|
|
UInt32 state);
|
|
|
|
|
|
/* Fill out the fCookie, fCode, and fResult fields before calling!*/
|
|
/*
|
|
* OTSMComplete()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTSMComplete(OTStateMachine * sm);
|
|
|
|
|
|
/*
|
|
* OTSMPopCallback()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTSMPopCallback(OTStateMachine * sm);
|
|
|
|
|
|
/*
|
|
* OTSMWaitForComplete()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
OTSMWaitForComplete(OTStateMachine * sm);
|
|
|
|
|
|
/*
|
|
* OTSMCreateStream()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
OTSMCreateStream(
|
|
OTStateMachine * sm,
|
|
OTConfigurationRef cfig,
|
|
OTOpenFlags flags);
|
|
|
|
|
|
/*
|
|
* OTSMOpenStream()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
OTSMOpenStream(
|
|
OTStateMachine * sm,
|
|
const char * name,
|
|
OTOpenFlags flags);
|
|
|
|
|
|
/*
|
|
* OTSMIoctl()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
OTSMIoctl(
|
|
OTStateMachine * sm,
|
|
StreamRef strm,
|
|
UInt32 cmd,
|
|
long data);
|
|
|
|
|
|
/*
|
|
* OTSMPutMessage()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
OTSMPutMessage(
|
|
OTStateMachine * sm,
|
|
StreamRef strm,
|
|
strbuf * ctlbuf,
|
|
strbuf * databuf,
|
|
OTFlags flags);
|
|
|
|
|
|
/*
|
|
* OTSMGetMessage()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
OTSMGetMessage(
|
|
OTStateMachine * sm,
|
|
StreamRef strm,
|
|
strbuf * ctlbuf,
|
|
strbuf * databuf,
|
|
OTFlags * flagsPtr);
|
|
|
|
|
|
/*
|
|
* OTSMReturnToCaller()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OSStatus )
|
|
OTSMReturnToCaller(OTStateMachine * sm);
|
|
|
|
|
|
/*
|
|
* OTSMGetClientData()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void * )
|
|
OTSMGetClientData(OTStateMachine * sm);
|
|
|
|
|
|
/*
|
|
* OTSMInstallCompletionProc()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTSMInstallCompletionProc(
|
|
OTStateMachine * sm,
|
|
OTSMCompleteProcPtr completeProc,
|
|
void * contextPtr);
|
|
|
|
|
|
/*
|
|
* OTSMCreateControlStream()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
OTSMCreateControlStream(
|
|
OTStateMachine * sm,
|
|
OTConfigurationRef cfig,
|
|
TOTConfiguratorRef cfigor);
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
inline void* OTStateMachine::GetClientData() { return OTSMGetClientData(this); }
|
|
inline Boolean OTStateMachine::CallStateProc(OTStateProcPtr proc, UInt32 state)
|
|
{ return OTSMCallStateProc(this, proc, state); }
|
|
inline UInt16 OTStateMachine::GetState() { return OTSMGetState(this); }
|
|
inline void OTStateMachine::SetState(UInt32 state)
|
|
{ OTSMSetState(this, state); }
|
|
inline void OTStateMachine::PopCallback() { OTSMPopCallback(this); }
|
|
inline void OTStateMachine::Complete() { OTSMComplete(this); }
|
|
inline void OTStateMachine::Complete(OTResult result, OTEventCode code, void* cookie)
|
|
{ fCookie = cookie; fCode = code; fResult = result; Complete(); }
|
|
inline void OTStateMachine::Complete(OTResult result)
|
|
{ fResult = result; Complete(); }
|
|
inline void OTStateMachine::CompleteToClient()
|
|
{ PopCallback(); Complete(); }
|
|
inline void OTStateMachine::CompleteToClient(OTResult result)
|
|
{ fResult = result; CompleteToClient(); }
|
|
|
|
inline void OTStateMachine::CompleteToClient(OTResult result, OTEventCode code, void* cookie)
|
|
{ fCookie = cookie; fCode = code; fResult = result; CompleteToClient(); }
|
|
inline Boolean OTStateMachine::CreateStream(OTConfigurationRef cfig, OTOpenFlags flags)
|
|
{ return OTSMCreateStream(this, cfig, flags); }
|
|
inline Boolean OTStateMachine::OpenStream(const char* name, OTOpenFlags flags)
|
|
{ return OTSMOpenStream(this, name, flags); }
|
|
inline Boolean OTStateMachine::SendIoctl(StreamRef ref, UInt32 type, void* data)
|
|
{ return OTSMIoctl(this, ref, type, (long)data); }
|
|
inline Boolean OTStateMachine::SendIoctl(StreamRef ref, UInt32 type, long data)
|
|
{ return OTSMIoctl(this, ref, type, data); }
|
|
inline Boolean OTStateMachine::PutMessage(StreamRef ref, struct strbuf* ctl, struct strbuf* data, OTFlags flags)
|
|
{ return OTSMPutMessage(this, ref, ctl, data, flags); }
|
|
inline Boolean OTStateMachine::GetMessage(StreamRef ref, struct strbuf* ctl, struct strbuf* data, OTFlags* flagPtr)
|
|
{ return OTSMGetMessage(this, ref, ctl, data, flagPtr); }
|
|
inline OSStatus OTStateMachine::ReturnToCaller()
|
|
{ return OTSMReturnToCaller(this); }
|
|
#endif
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
#endif /* !OTKERNEL */
|
|
|
|
/* ***** Autopush Definitions ******/
|
|
/*
|
|
The autopush functionality for Open Transport is based on the names of
|
|
devices and modules, rather than on the major number information like
|
|
SVR4. This is so that autopush information can be set up for modules
|
|
that are not yet loaded.
|
|
*/
|
|
|
|
|
|
/* The name of the STREAMS driver you open and send the ioctls to.*/
|
|
#define kSADModuleName "sad"
|
|
/* Autopush ioctls.*/
|
|
enum {
|
|
I_SAD_SAP = ((MIOC_SAD << 8) | 1), /* Set autopush information */
|
|
I_SAD_GAP = ((MIOC_SAD << 8) | 2), /* Get autopush information */
|
|
I_SAD_VML = ((MIOC_SAD << 8) | 3) /* Validate a list of modules (uses str_list structure) */
|
|
};
|
|
|
|
/* Maximum number of modules autopushed on a driver.*/
|
|
|
|
enum {
|
|
kOTAutopushMax = 8
|
|
};
|
|
|
|
|
|
/* ioctl structure used for SAD_SAP and SAD_GAP commands.*/
|
|
|
|
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;
|
|
/* Command values for sap_cmd field of the above.*/
|
|
enum {
|
|
kSAP_ONE = 1, /* Configure a single minor device */
|
|
kSAP_RANGE = 2, /* Configure a range of minor devices */
|
|
kSAP_ALL = 3, /* Configure all minor devices */
|
|
kSAP_CLEAR = 4 /* Clear autopush information */
|
|
};
|
|
|
|
|
|
/* ***** Configuration Helpers ******/
|
|
|
|
/*
|
|
These definitions are used by device driver and port scanner
|
|
developers to provide a library giving client-side information about
|
|
the registered ports, such as a user-visible name or an icon.
|
|
*/
|
|
|
|
/* Configuration helper library prefix*/
|
|
|
|
/*
|
|
This prefix is prepended to the string found in the "fResourceInfo"
|
|
field of the OTPortRecord to build the actual library name of the
|
|
configuration helper library.
|
|
*/
|
|
|
|
#define kPortConfigLibPrefix "OTPortCfg$"
|
|
|
|
/* Get user visible port name entry point.*/
|
|
|
|
/*
|
|
This entry point returns the user visible name of the port. If includeSlot
|
|
is true, a slot distinguishing suffix (eg "slot X") should be added. If
|
|
includePort is true, a port distinguishing suffix (eg " port X") should be added for
|
|
multiport cards.
|
|
*/
|
|
|
|
#define kOTGetUserPortNameID "OTGetUserPortName"
|
|
typedef CALLBACK_API_C( void , OTGetPortNameProcPtr )(OTPortRecord *port, OTBooleanParam includeSlot, OTBooleanParam includePort, Str255 userVisibleName);
|
|
/* Get icon entry point.*/
|
|
/*
|
|
This entry point returns the location of the icon for the port. Return false if no
|
|
icon is provided.
|
|
*/
|
|
|
|
#define kOTGetPortIconID "OTGetPortIcon"
|
|
struct OTResourceLocator {
|
|
FSSpec fFile;
|
|
UInt16 fResID;
|
|
};
|
|
typedef struct OTResourceLocator OTResourceLocator;
|
|
typedef CALLBACK_API_C( Boolean , OTGetPortIconProcPtr )(OTPortRecord *port, OTResourceLocator *iconLocation);
|
|
/* ***** Application Access to Configuration Helpers ******/
|
|
|
|
#if !OTKERNEL
|
|
/*
|
|
These routines are used by clients to get information about ports.
|
|
The canonical user of these routines is the OT control panel(s),
|
|
but applications may want to use them as well (to display the list
|
|
of available Ethernet cards, for example).
|
|
*/
|
|
/* Returns a user friendly name for a port.*/
|
|
#if CALL_NOT_IN_CARBON
|
|
/*
|
|
* OTGetUserPortNameFromPortRef()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTGetUserPortNameFromPortRef(
|
|
OTPortRef ref,
|
|
Str255 friendlyName);
|
|
|
|
|
|
/*
|
|
Returns the location for the icon familly representing the port.
|
|
Returns false if the port has no icon.
|
|
*/
|
|
/*
|
|
* OTGetPortIconFromPortRef()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
OTGetPortIconFromPortRef(
|
|
OTPortRef ref,
|
|
OTResourceLocator * iconLocation);
|
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
/* Returns true if the port can be used with the specified protocol.*/
|
|
#if CALL_NOT_IN_CARBON
|
|
/*
|
|
* OTIsPortCompatibleWith()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
OTIsPortCompatibleWith(
|
|
const OTPortRecord * port,
|
|
char * protocolName);
|
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
#endif /* !OTKERNEL */
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
/* ***** Common Utilities ******/
|
|
/*
|
|
The utilities defined in this section are available to both client
|
|
and kernel code. Cool huh? These utilities differ from those
|
|
provided in "OpenTransport.h" in that they are only available to native
|
|
architecture clients.
|
|
*/
|
|
|
|
/* Bitmap functions*/
|
|
|
|
/* These functions atomically deal with a bitmap that is multiple-bytes long*/
|
|
|
|
/*
|
|
Set the first clear bit in "bitMap", starting with bit "startBit",
|
|
giving up after "numBits". Returns the bit # that was set, or
|
|
a kOTNotFoundErr if there was no clear bit available
|
|
*/
|
|
/*
|
|
* OTSetFirstClearBit()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later
|
|
* CarbonLib: in CarbonLib 1.0 and later
|
|
* Mac OS X: in version 10.0 and later
|
|
*/
|
|
EXTERN_API_C( OTResult )
|
|
OTSetFirstClearBit(
|
|
UInt8 * bitMap,
|
|
OTByteCount startBit,
|
|
OTByteCount numBits);
|
|
|
|
|
|
/* Standard clear, set and test bit functions*/
|
|
/*
|
|
* OTClearBit()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later
|
|
* CarbonLib: in CarbonLib 1.0 and later
|
|
* Mac OS X: in version 10.0 and later
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
OTClearBit(
|
|
UInt8 * bitMap,
|
|
OTByteCount bitNo);
|
|
|
|
|
|
/*
|
|
* OTSetBit()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later
|
|
* CarbonLib: in CarbonLib 1.0 and later
|
|
* Mac OS X: in version 10.0 and later
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
OTSetBit(
|
|
UInt8 * bitMap,
|
|
OTByteCount bitNo);
|
|
|
|
|
|
/*
|
|
* OTTestBit()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later
|
|
* CarbonLib: in CarbonLib 1.0 and later
|
|
* Mac OS X: in version 10.0 and later
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
OTTestBit(
|
|
UInt8 * bitMap,
|
|
OTByteCount bitNo);
|
|
|
|
|
|
/* OTHashList*/
|
|
|
|
/*
|
|
This implements a simple, but efficient hash list. It is not
|
|
thread-safe.
|
|
*/
|
|
|
|
typedef CALLBACK_API_C( UInt32 , OTHashProcPtr )(OTLink * linkToHash);
|
|
typedef CALLBACK_API_C( Boolean , OTHashSearchProcPtr )(const void *ref, OTLink *linkToCheck);
|
|
struct OTHashList {
|
|
OTHashProcPtr fHashProc;
|
|
ByteCount fHashTableSize;
|
|
OTLink ** fHashBuckets;
|
|
#ifdef __cplusplus
|
|
|
|
// C++ inline methods on this structure.
|
|
|
|
|
|
|
|
void Add(OTLink* toAdd);
|
|
|
|
Boolean RemoveLink(OTLink* toRemove);
|
|
|
|
OTLink* Remove(OTHashSearchProcPtr proc, const void* refPtr, UInt32 hashValue);
|
|
|
|
Boolean IsInList(OTLink* toFind);
|
|
|
|
OTLink* FindLink(OTHashSearchProcPtr proc, const void* refPtr, UInt32 hash);
|
|
|
|
#endif
|
|
|
|
};
|
|
typedef struct OTHashList OTHashList;
|
|
/*
|
|
Return the number of bytes of memory needed to create a hash list
|
|
of at least "numEntries" entries.
|
|
*/
|
|
#if CALL_NOT_IN_CARBON
|
|
/*
|
|
* OTCalculateHashListMemoryNeeds()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OTByteCount )
|
|
OTCalculateHashListMemoryNeeds(OTItemCount numEntries);
|
|
|
|
|
|
/*
|
|
Create an OTHashList from "memory". Return an error if it
|
|
couldn't be done.
|
|
*/
|
|
/*
|
|
* OTInitHashList()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OTResult )
|
|
OTInitHashList(
|
|
void * memory,
|
|
OTByteCount numBytes,
|
|
OTHashProcPtr hashProc);
|
|
|
|
|
|
/*
|
|
* OTAddToHashList()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTAddToHashList(
|
|
OTHashList * hashList,
|
|
OTLink * linkToAdd);
|
|
|
|
|
|
/*
|
|
* OTRemoveLinkFromHashList()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
OTRemoveLinkFromHashList(
|
|
OTHashList * hashList,
|
|
OTLink * linkToRemove);
|
|
|
|
|
|
/*
|
|
* OTIsInHashList()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
OTIsInHashList(
|
|
OTHashList * hashList,
|
|
OTLink * link);
|
|
|
|
|
|
/*
|
|
* OTFindInHashList()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OTLink * )
|
|
OTFindInHashList(
|
|
OTHashList * hashList,
|
|
OTHashSearchProcPtr searchProc,
|
|
const void * refPtr,
|
|
UInt32 hashValue);
|
|
|
|
|
|
/*
|
|
* OTRemoveFromHashList()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OTLink * )
|
|
OTRemoveFromHashList(
|
|
OTHashList * hashList,
|
|
OTHashSearchProcPtr searchProc,
|
|
const void * refPtr,
|
|
UInt32 hashValue);
|
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
#ifdef __cplusplus
|
|
#if CALL_NOT_IN_CARBON
|
|
// C++ inline methods on this structure.
|
|
|
|
inline void OTHashList::Add(OTLink* toAdd) { OTAddToHashList(this, toAdd); }
|
|
|
|
inline Boolean OTHashList::RemoveLink(OTLink* toRemove)
|
|
{ return OTRemoveLinkFromHashList(this, toRemove); }
|
|
inline OTLink* OTHashList::Remove(OTHashSearchProcPtr proc, const void* refPtr, UInt32 hashValue)
|
|
{ return OTRemoveFromHashList(this, proc, refPtr, hashValue); }
|
|
inline Boolean OTHashList::IsInList(OTLink* toFind)
|
|
{ return OTIsInHashList(this, toFind); }
|
|
inline OTLink* OTHashList::FindLink(OTHashSearchProcPtr proc, const void* refPtr, UInt32 hash)
|
|
{ return OTFindInHashList(this, proc, refPtr, hash); }
|
|
#endif
|
|
#endif
|
|
/* Random functions*/
|
|
|
|
/*
|
|
These implement a very simple random number generator, suitable
|
|
for protocol implementations but not "cryptographically" random.
|
|
*/
|
|
|
|
#if CALL_NOT_IN_CARBON
|
|
/*
|
|
* OTGetRandomSeed()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( UInt32 )
|
|
OTGetRandomSeed(void);
|
|
|
|
|
|
/*
|
|
* OTGetRandomNumber()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( UInt32 )
|
|
OTGetRandomNumber(
|
|
UInt32 * seed,
|
|
UInt32 lo,
|
|
UInt32 hi);
|
|
|
|
|
|
/* Concurrency Control*/
|
|
|
|
/*
|
|
OTGate implements a cool concurrency control primitive.
|
|
You're not going to understand it without reading the documentation!
|
|
See "Open Transport Advanced Client Programming" for details.
|
|
WARNING:
|
|
This structure must be on a 4-byte boundary.
|
|
*/
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
typedef CALLBACK_API_C( Boolean , OTGateProcPtr )(OTLink * thisLink);
|
|
struct OTGate {
|
|
OTLIFO fLIFO;
|
|
OTList fList;
|
|
OTGateProcPtr fProc;
|
|
SInt32 fNumQueued;
|
|
SInt32 fInside;
|
|
};
|
|
typedef struct OTGate OTGate;
|
|
#if CALL_NOT_IN_CARBON
|
|
/*
|
|
* OTInitGate()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTInitGate(
|
|
OTGate * gate,
|
|
OTGateProcPtr proc);
|
|
|
|
|
|
/*
|
|
* OTEnterGate()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
OTEnterGate(
|
|
OTGate * gate,
|
|
OTLink * withLink);
|
|
|
|
|
|
/*
|
|
* OTLeaveGate()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( Boolean )
|
|
OTLeaveGate(OTGate * gate);
|
|
|
|
|
|
/* ***** Shared Library Bonus Extras ******/
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
#if CALL_NOT_IN_CARBON
|
|
/*
|
|
These routines provide addition shared library support beyond
|
|
that provided by the base shared library mechanism.
|
|
*/
|
|
/*
|
|
Some flags which can be passed to the "loadFlags" parameter of the
|
|
various CFM routines. Not all flags can be used with all routines.
|
|
See "Open Transport Advanced Client Programming" for details.
|
|
*/
|
|
|
|
enum {
|
|
kOTGetDataSymbol = 0,
|
|
kOTGetCodeSymbol = 1,
|
|
kOTLoadNewCopy = 2,
|
|
kOTLoadACopy = 4,
|
|
kOTFindACopy = 8,
|
|
kOTLibMask = kOTLoadNewCopy | kOTLoadACopy | kOTFindACopy,
|
|
kOTLoadLibResident = 0x20
|
|
};
|
|
|
|
/* Finding all matching CFM libraries.*/
|
|
|
|
/*
|
|
The routine OTFindCFMLibraries allows you to find all CFM libraries
|
|
that match specific criteria. The result is placed in a list
|
|
of CFMLibraryInfo structures. OT allocates those structures using
|
|
a routine of type OTAllocMemProcPtr that you pass to OTFindCFMLibraries.
|
|
*/
|
|
|
|
/*
|
|
A list of CFMLibraryInfo structures is returned by the OTFindCFMLibraries routine.
|
|
The list is created out of the data that is passed to the function.
|
|
|
|
IMPORTANT:
|
|
Only the first 3 fields are valid when using OT 1.2 and older.
|
|
*/
|
|
|
|
struct CFMLibraryInfo {
|
|
OTLink link; /* To link them all up on a list */
|
|
char * libName; /* "C" String which is fragment name */
|
|
StringPtr intlName; /* Pascal String which is internationalized name */
|
|
FSSpec * fileSpec; /* location of fragment's file */
|
|
StringPtr pstring2; /* Secondary string from extended cfrg */
|
|
StringPtr pstring3; /* Extra info from extended cfrg */
|
|
};
|
|
typedef struct CFMLibraryInfo CFMLibraryInfo;
|
|
/*
|
|
You must pass a routine of type OTAllocMemProcPtr to OTFindCFMLibraries
|
|
which it calls to allocate memory for the CFMLibraryInfo structures.
|
|
*/
|
|
typedef CALLBACK_API_C( void *, OTAllocMemProcPtr )(OTByteCount size);
|
|
/* Find CFM libraries of the specified kind and type*/
|
|
#if CALL_NOT_IN_CARBON
|
|
/*
|
|
* OTFindCFMLibraries()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OSStatus )
|
|
OTFindCFMLibraries(
|
|
OSType libKind,
|
|
const char * libType,
|
|
OTList * theList,
|
|
OTAllocMemProcPtr allocator);
|
|
|
|
|
|
/* Loading libraries and connecting to symbols.*/
|
|
|
|
/* Load a CFM library by name*/
|
|
/*
|
|
* OTLoadCFMLibrary()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OSStatus )
|
|
OTLoadCFMLibrary(
|
|
const char * libName,
|
|
UInt32 * connID,
|
|
UInt32 loadFlags);
|
|
|
|
|
|
/* Load a CFM library and get a named pointer from it*/
|
|
/*
|
|
* OTGetCFMPointer()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void * )
|
|
OTGetCFMPointer(
|
|
const char * libName,
|
|
const char * entryName,
|
|
UInt32 * connID,
|
|
UInt32 loadFlags);
|
|
|
|
|
|
/* Get a named pointer from a CFM library that's already loaded*/
|
|
/*
|
|
* OTGetCFMSymbol()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void * )
|
|
OTGetCFMSymbol(
|
|
const char * entryName,
|
|
UInt32 connID,
|
|
UInt32 loadFlags);
|
|
|
|
|
|
/* Release a connection to a CFM library*/
|
|
/*
|
|
* OTReleaseCFMConnection()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTReleaseCFMConnection(UInt32 * connID);
|
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
#if !TARGET_CPU_68K
|
|
/*
|
|
You can call these routines in your CFM initialisation and termination
|
|
routines to hold or unhold your libraries sections.
|
|
*/
|
|
/*
|
|
Used in a CFM InitProc, will hold the executable code, if applicable.
|
|
This can also be the InitProc of the library
|
|
*/
|
|
#if CALL_NOT_IN_CARBON
|
|
/*
|
|
* OTHoldThisCFMLibrary()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OSStatus )
|
|
OTHoldThisCFMLibrary(const CFragInitBlock * initBlock);
|
|
|
|
|
|
/*
|
|
Used in a CFM terminate proc, will unhold the executable code, if applicable.
|
|
This can also be the terminate proc of the library
|
|
*/
|
|
/*
|
|
* OTUnholdThisCFMLibrary()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTUnholdThisCFMLibrary(void);
|
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
#endif /* !TARGET_CPU_68K */
|
|
|
|
/* ASLM Utilities*/
|
|
/* Load an ASLM library*/
|
|
#if CALL_NOT_IN_CARBON
|
|
/*
|
|
* OTLoadASLMLibrary()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( OSStatus )
|
|
OTLoadASLMLibrary(const char * libName);
|
|
|
|
|
|
/* Unload an ASLM library*/
|
|
/*
|
|
* OTUnloadASLMLibrary()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
OTUnloadASLMLibrary(const char * libName);
|
|
|
|
|
|
/*
|
|
This is an ASLM utility routine. You can get it by including
|
|
"LibraryManagerUtilities.h", but since we only use a few ASLM utilities,
|
|
we put the prototype here for convenience.
|
|
*/
|
|
|
|
/*
|
|
* UnloadUnusedLibraries()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available
|
|
* Mac OS X: not available
|
|
*/
|
|
EXTERN_API_C( void )
|
|
UnloadUnusedLibraries(void);
|
|
|
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
#if !OTKERNEL
|
|
/*******************************************************************************
|
|
** A few C++ objects for C++ fans
|
|
********************************************************************************/
|
|
#if CALL_NOT_IN_CARBON
|
|
|
|
#ifdef __cplusplus
|
|
} // Terminate C definitions
|
|
|
|
class OTConfiguration
|
|
{
|
|
public:
|
|
OTConfigurationRef Clone()
|
|
{ return OTCfigCloneConfiguration(this); }
|
|
//
|
|
// The Path for PushChild and PushParent must be a single module
|
|
//
|
|
OTConfigurationRef PushChild(const char* path, OSStatus* errPtr)
|
|
{ return OTCfigPushNewSingleChild(this, path, errPtr); }
|
|
OTConfigurationRef PushParent(const char* path, OSStatus* errPtr)
|
|
{ return OTCfigPushParent(this, path, errPtr); }
|
|
OTConfigurationRef PushNthChild(OTItemCount index, const char* path,
|
|
OSStatus* errPtr)
|
|
{ return OTCfigPushChild(this, index, path, errPtr); }
|
|
OSStatus PopChild(OTItemCount index)
|
|
{ return OTCfigPopChild(this, index); }
|
|
|
|
OTConfigurationRef GetChild(OTItemCount index = 0)
|
|
{ return OTCfigGetChild(this, index); }
|
|
OTConfigurationRef GetParent()
|
|
{ return OTCfigGetParent(this); }
|
|
|
|
OSStatus AddChild(OTConfigurationRef child)
|
|
{ return OTCfigAddChild(this, child); }
|
|
|
|
OTConfigurationRef NewChild(const char* path, OSStatus* errPtr)
|
|
{ return OTCfigNewChild(this, path, errPtr); }
|
|
|
|
OSStatus SetPath(const char* path)
|
|
{ return OTCfigSetPath(this, path); }
|
|
|
|
Boolean HasOptions()
|
|
{ return OTCfigGetOptionNetbuf(this)->len != 0; }
|
|
};
|
|
|
|
/* -------------------------------------------------------------------------
|
|
Class TOTConfigurator
|
|
|
|
This class is subclassed to do configuration for a protocol or protocol stack.
|
|
Of course, you can also use OTNewConfigurator to do it from C.
|
|
|
|
If you subclass it using C++, you MUST have a UInt32 field as the first
|
|
field of your object that you do not touch or use.
|
|
------------------------------------------------------------------------- */
|
|
|
|
#if TARGET_CPU_68K && !defined(__SC__) && !defined(THINK_CPLUS)
|
|
class TOTConfigurator : public SingleObject
|
|
#else
|
|
class TOTConfigurator
|
|
#endif
|
|
{
|
|
#if defined(__SC__) || defined(THINK_CPLUS) || defined(__MRC__)
|
|
private:
|
|
virtual void DummyVirtualFunction();
|
|
#endif
|
|
|
|
public:
|
|
void* operator new(size_t size)
|
|
{ return OTAllocSharedClientMem((OTByteCount)size); }
|
|
void operator delete(void* mem)
|
|
{ OTFreeSharedClientMem(mem); };
|
|
|
|
_MDECL TOTConfigurator();
|
|
virtual ~ _MDECL TOTConfigurator();
|
|
|
|
virtual void _MDECL HandleSystemEvent(OTEventCode event, OTResult result,
|
|
void* cookie) = 0;
|
|
|
|
virtual OSStatus _MDECL Configure(OTConfigurationRef) = 0;
|
|
virtual OSStatus _MDECL CreateStream(OTConfigurationRef, OTOpenFlags,
|
|
OTNotifyUPP, void* contextPtr) = 0;
|
|
};
|
|
|
|
extern "C" { // resume C definitions
|
|
#endif /*__cplusplus*/
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
#endif /* !OTKERNEL */
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */
|
|
|
|
#if defined(__MWERKS__) && TARGET_CPU_68K
|
|
#pragma pop
|
|
#endif
|
|
|
|
|
|
#if PRAGMA_STRUCT_ALIGN
|
|
#pragma options align=reset
|
|
#elif PRAGMA_STRUCT_PACKPUSH
|
|
#pragma pack(pop)
|
|
#elif PRAGMA_STRUCT_PACK
|
|
#pragma pack()
|
|
#endif
|
|
|
|
#ifdef PRAGMA_IMPORT_OFF
|
|
#pragma import off
|
|
#elif PRAGMA_IMPORT
|
|
#pragma import reset
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* __OPENTRANSPORTPROTOCOL__ */
|
|
|