tf2/tf2_src/common/quicktime_win32/OpenTransportProtocol.h

/*
     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__ */