OpenTransportProtocol.h

Go to the documentation of this file.

 
#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 
#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
 
#ifndef OTKERNEL
#error OpenTransportProtocol.h expects OpenTransport.h to set up OTKERNEL.
#endif 
#if !OTKERNEL
#if CALL_NOT_IN_CARBON
  void *
  OTAllocSharedClientMem(OTByteCount size);
 
  void
  OTFreeSharedClientMem(void *mem);
 
#endif 
#endif 
#if CALL_NOT_IN_CARBON
  typedef UInt32 uid_t;
  typedef UInt32 gid_t;
  typedef UInt32 dev_t;
  struct module_stat
  {
    long ms_pcnt;   
    long ms_scnt;   
    long ms_ocnt;   
    long ms_ccnt;   
    long ms_acnt;   
    char *ms_xptr;  
    short ms_xsize; 
  };
  typedef struct module_stat module_stat;
  struct cred
  {
    UInt16 cr_ref;      
    UInt16 cr_ngroups;  
    uid_t cr_uid;       
    gid_t cr_gid;       
    uid_t cr_ruid;      
    gid_t cr_rgid;      
    uid_t cr_suid;      
    gid_t cr_sgid;      
    gid_t cr_groups[1]; 
  };
  typedef struct cred cred;
  typedef cred cred_t;
  typedef CALLBACK_API_C(void, FreeFuncType)(char *arg);
  struct free_rtn
  {
    FreeFuncType free_func; 
    char *free_arg;         
  };
  typedef struct free_rtn free_rtn;
  typedef free_rtn frtn_t;
  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;    
    unsigned char *db_lim;     
    unsigned char db_ref;      
    unsigned char db_type;     
    unsigned char db_iswhat;   
    unsigned char db_filler2;  
    UInt32 db_size;            
    unsigned char *db_msgaddr; 
    long db_filler;
  };
 
  typedef datab dblk_t;
#define db_freep db_f.freep
#define db_frtnp db_f.frtnp
 
  struct msgb
  {
    struct msgb *b_next;   
    struct msgb *b_prev;   
    struct msgb *b_cont;   
    unsigned char *b_rptr; 
    unsigned char *b_wptr; 
    datab *b_datap;        
    unsigned char b_band;  
    unsigned char b_pad1;
    unsigned short b_flag;
#ifdef MSGB_XTRA
 
    MSGB_XTRA
 
#endif
  };
  typedef struct msgb msgb;
  typedef msgb mblk_t;
  enum
  {
    MSGMARK = 0x01,   
    MSGNOLOOP = 0x02, 
    MSGDELIM = 0x04,  
    MSGNOGET = 0x08
  };
 
  enum
  {
    STRCTLSZ = 256, 
    STRMSGSZ = 8192 
  };
 
  enum
  {
    QNORM = 0,
    M_DATA = 0,       
    M_PROTO = 1,      
    M_BREAK = 0x08,   
    M_PASSFP = 0x09,  
    M_SIG = 0x0B,     
    M_DELAY = 0x0C,   
    M_CTL = 0x0D,     
    M_IOCTL = 0x0E,   
    M_SETOPTS = 0x10, 
    M_RSE = 0x11      
  };
 
  enum
  {
    M_MI = 0x40,
    M_MI_READ_RESET = 1,
    M_MI_READ_SEEK = 2,
    M_MI_READ_END = 4
  };
 
  enum
  {
    QPCTL = 0x80,
    M_IOCACK = 0x81,  
    M_IOCNAK = 0x82,  
    M_PCPROTO = 0x83, 
    M_PCSIG = 0x84,   
    M_FLUSH = 0x86,   
    M_STOP = 0x87,    
    M_START = 0x88,   
    M_HANGUP = 0x89,  
    M_ERROR = 0x8A,   
    M_READ = 0x8B,    
    M_COPYIN = 0x8C,  
    M_COPYOUT = 0x8D, 
    M_IOCDATA = 0x8E, 
    M_PCRSE = 0x90,   
    M_STOPI = 0x91,   
    M_STARTI = 0x92,  
    M_HPDATA = 0x93   
  };
 
  enum
  {
    FLUSHALL = 1,
    FLUSHDATA = 0
  };
 
  enum
  {
    NOERROR = -1 
  };
 
  typedef struct sth_s sth_s;
  typedef struct sqh_s sqh_s;
  typedef struct q_xtra q_xtra;
#if OTKERNEL
#if TARGET_CPU_PPC
#pragma options align = power
#endif
  struct module_info
  {
    unsigned short mi_idnum; 
    char *mi_idname;         
    long mi_minpsz;          
    long mi_maxpsz;          
    unsigned long mi_hiwat;  
    unsigned long mi_lowat;  
  };
  typedef struct module_info module_info;
  typedef module_info *module_infoPtr;
#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;        
    srvp_t qi_srvp;        
    openp_t qi_qopen;      
    closep_t qi_qclose;    
    admin_t qi_qadmin;     
    module_info *qi_minfo; 
    module_stat *qi_mstat; 
  };
  typedef struct qinit qinit;
  struct streamtab
  {
    qinit *st_rdinit;   
    qinit *st_wrinit;   
    qinit *st_muxrinit; 
    qinit *st_muxwinit; 
  };
  typedef struct streamtab streamtab;
  struct qband
  {
    struct qband *qb_next;  
    unsigned long qb_count; 
    msgb *qb_first;         
    msgb *qb_last;          
    unsigned long qb_hiwat; 
    unsigned long qb_lowat; 
    unsigned short qb_flag; 
    short qb_pad1;          
  };
  typedef struct qband qband;
  typedef qband qband_t;
  union queue_q_u
  {
    queue *q_u_link; 
    sqh_s *q_u_sqh_parent;
  };
  typedef union queue_q_u queue_q_u;
  struct queue
  {
    qinit *q_qinfo;       
    msgb *q_first;        
    msgb *q_last;         
    struct queue *q_next; 
    queue_q_u q_u;
    char *q_ptr;             
    unsigned long q_count;   
    long q_minpsz;           
    long q_maxpsz;           
    unsigned long q_hiwat;   
    unsigned long q_lowat;   
    qband *q_bandp;          
    unsigned short q_flag;   
    unsigned char q_nband;   
    unsigned char q_pad1[1]; 
    q_xtra *q_osx;           
    struct queue *q_ffcp;    
    struct queue *q_bfcp;    
  };
 
  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
 
  enum
  {
    QREADR = 0x01,         
    QNOENB = 0x02,         
    QFULL = 0x04,          
    QWANTR = 0x08,         
    QWANTW = 0x10,         
    QUSE = 0x20,           
    QENAB = 0x40,          
    QBACK = 0x80,          
    QOLD = 0x0100,         
    QHLIST = 0x0200,       
    QWELDED = 0x0400,      
    QUNWELDING = 0x0800,   
    QPROTECTED = 0x1000,   
    QEXCOPENCLOSE = 0x2000 
  };
 
  enum
  {
    QB_FULL = 0x01, 
    QB_WANTW =
        0x02,      
    QB_BACK = 0x04 
  };
 
#else
  typedef SInt32 queue_t;
#endif 
  typedef char *caddr_t;
  struct copyreq
  {
    SInt32 cq_cmd;      
    cred *cq_cr;        
    UInt32 cq_id;       
    caddr_t cq_addr;    
    UInt32 cq_size;     
    SInt32 cq_flag;     
    mblk_t *cq_private; 
    long cq_filler[4];
  };
  typedef struct copyreq copyreq;
#define cq_uid cq_cr->cr_uid
#define cq_gid cq_cr->cr_gid
 
  enum
  {
    STRCANON = 0x01, 
    RECOPY = 0x02    
  };
 
  struct copyresp
  {
    SInt32 cp_cmd; 
    cred *cp_cr;   
    UInt32 cp_id;  
    caddr_t
        cp_rval; 
    UInt32 cp_pad1;
    SInt32 cp_pad2;
    mblk_t *cp_private; 
    long cp_filler[4];
  };
  typedef struct copyresp copyresp;
#define cp_uid cp_cr->cr_uid
#define cp_gid cp_cr->cr_gid
 
  struct iocblk
  {
    SInt32 ioc_cmd;   
    cred *ioc_cr;     
    UInt32 ioc_id;    
    UInt32 ioc_count; 
    SInt32 ioc_error; 
    SInt32 ioc_rval;  
    long ioc_filler[4];
  };
  typedef struct iocblk iocblk;
#define ioc_uid ioc_cr->cr_uid
#define ioc_gid ioc_cr->cr_gid
 
  enum
  {
    TRANSPARENT = (unsigned long)0xFFFFFFFF
  };
 
  struct linkblk
  {
    queue_t *l_qtop; 
    queue_t *l_qbot; 
    SInt32 l_index;  
    long l_pad[5];
  };
  typedef struct linkblk linkblk;
  struct strpfp
  {
    unsigned long pass_file_cookie; 
    unsigned short pass_uid;        
    unsigned short pass_gid;
    sth_s *pass_sth; 
  };
  typedef struct strpfp strpfp;
  struct stroptions
  {
    unsigned long so_flags;     
    short so_readopt;           
    unsigned short so_wroff;    
    long so_minpsz;             
    long so_maxpsz;             
    unsigned long so_hiwat;     
    unsigned long so_lowat;     
    unsigned char so_band;      
    unsigned char so_filler[3]; 
    unsigned long so_poll_set;  
    unsigned long so_poll_clr;  
  };
  typedef struct stroptions stroptions;
  enum
  {
    SO_ALL = 0x7FFF,         
    SO_READOPT = 0x0001,     
    SO_WROFF = 0x0002,       
    SO_MINPSZ = 0x0004,      
    SO_MAXPSZ = 0x0008,      
    SO_HIWAT = 0x0010,       
    SO_LOWAT = 0x0020,       
    SO_MREADON = 0x0040,     
    SO_MREADOFF = 0x0080,    
    SO_NDELON = 0x0100,      
    SO_NDELOFF = 0x0200,     
    SO_ISTTY = 0x0400,       
    SO_ISNTTY = 0x0800,      
    SO_TOSTOP = 0x1000,      
    SO_TONSTOP = 0x2000,     
    SO_BAND = 0x4000,        
    SO_POLL_SET = 0x8000,    
    SO_POLL_CLR = 0x00010000 
  };
 
  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
  };
 
  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 
  enum
  {
    I_NREAD =
        ((MIOC_STREAMIO << 8) | 1),      
    I_PUSH = ((MIOC_STREAMIO << 8) | 2), 
    I_POP = ((MIOC_STREAMIO << 8) | 3),  
    I_LOOK =
        ((MIOC_STREAMIO << 8) | 4), 
    I_FLUSH =
        ((MIOC_STREAMIO << 8) | 5),         
    I_SRDOPT = ((MIOC_STREAMIO << 8) | 6),  
    I_GRDOPT = ((MIOC_STREAMIO << 8) | 7),  
    I_STR = ((MIOC_STREAMIO << 8) | 8),     
    I_SETSIG = ((MIOC_STREAMIO << 8) | 9),  
    I_GETSIG = ((MIOC_STREAMIO << 8) | 10), 
    I_FIND = ((MIOC_STREAMIO << 8) | 11),   
    I_LINK = ((MIOC_STREAMIO << 8) | 12),   
    I_UNLINK = ((MIOC_STREAMIO << 8) | 13), 
    I_PEEK = ((MIOC_STREAMIO << 8) | 15),   
    I_FDINSERT =
        ((MIOC_STREAMIO << 8) | 16), 
    I_SENDFD =
        ((MIOC_STREAMIO << 8) | 17),        
    I_RECVFD = ((MIOC_STREAMIO << 8) | 18), 
    I_FLUSHBAND = ((MIOC_STREAMIO << 8) |
                   19),                     
    I_SWROPT = ((MIOC_STREAMIO << 8) | 20), 
    I_GWROPT = ((MIOC_STREAMIO << 8) | 21), 
    I_LIST =
        ((MIOC_STREAMIO << 8) | 22), 
    I_ATMARK = ((MIOC_STREAMIO << 8) |
                23), 
    I_CKBAND = ((MIOC_STREAMIO << 8) |
                24), 
    I_GETBAND = ((MIOC_STREAMIO << 8) |
                 25), 
    I_CANPUT = ((MIOC_STREAMIO << 8) |
                26),                           
    I_SETCLTIME = ((MIOC_STREAMIO << 8) | 27), 
    I_GETCLTIME =
        ((MIOC_STREAMIO << 8) | 28), 
    I_PLINK = ((MIOC_STREAMIO << 8) |
               29),                           
    I_PUNLINK = ((MIOC_STREAMIO << 8) | 30),  
    I_GETMSG = ((MIOC_STREAMIO << 8) | 40),   
    I_PUTMSG = ((MIOC_STREAMIO << 8) | 41),   
    I_POLL = ((MIOC_STREAMIO << 8) | 42),     
    I_SETDELAY = ((MIOC_STREAMIO << 8) | 43), 
    I_GETDELAY = ((MIOC_STREAMIO << 8) | 44), 
    I_RUN_QUEUES =
        ((MIOC_STREAMIO << 8) | 45),         
    I_GETPMSG = ((MIOC_STREAMIO << 8) | 46), 
    I_PUTPMSG = ((MIOC_STREAMIO << 8) | 47), 
    I_AUTOPUSH = ((MIOC_STREAMIO << 8) |
                  48),                           
    I_PIPE = ((MIOC_STREAMIO << 8) | 49),        
    I_HEAP_REPORT = ((MIOC_STREAMIO << 8) | 50), 
    I_FIFO = ((MIOC_STREAMIO << 8) | 51)         
  };
 
  enum
  {
    RS_HIPRI = 0x01
  };
 
  enum
  {
    MSG_HIPRI = 0x01,
    MSG_BAND = 0x02, 
    MSG_ANY = 0x04   
  };
 
  enum
  {
    MORECTL = 0x01, 
    MOREDATA = 0x02 
  };
 
  enum
  {
    FMNAMESZ = 31 
  };
 
  enum
  {
    INFTIM = (unsigned long)0xFFFFFFFF
  };
 
  enum
  {
    FLUSHR = 0x01,              
    FLUSHW = 0x02,              
    FLUSHRW = (FLUSHW | FLUSHR) 
  };
 
  enum
  {
    FLUSHBAND = 0x40 
  };
 
  struct bandinfo
  {
    unsigned char bi_pri; 
    char pad1;
    SInt32 bi_flag; 
  };
  typedef struct bandinfo bandinfo;
  enum
  {
    ANYMARK = 0x01, 
    LASTMARK = 0x02 
  };
 
  enum
  {
    S_INPUT = 0x01,    
    S_HIPRI = 0x02,    
    S_OUTPUT = 0x04,   
    S_MSG = 0x08,      
    S_RDNORM = 0x10,   
    S_RDBAND = 0x20,   
    S_WRNORM = 0x40,   
    S_WRBAND = 0x80,   
    S_ERROR = 0x0100,  
    S_HANGUP = 0x0200, 
    S_BANDURG = 0x0400 
  };
 
  enum
  {
    RNORM = 0x01, 
    RMSGD = 0x02, 
    RMSGN = 0x04, 
    RFILL = 0x08  
  };
 
  enum
  {
    RPROTNORM =
        0x10,        
    RPROTDIS = 0x20, 
    RPROTDAT = 0x40  
  };
 
  enum
  {
    SNDZERO =
        0x01 
  };
 
  enum
  {
    MUXID_ALL = -1 
  };
 
  struct strfdinsert
  {
    strbuf ctlbuf;
    strbuf databuf;
    long flags;    
    long fildes;   
    SInt32 offset; 
  };
  typedef struct strfdinsert strfdinsert;
  struct str_mlist
  {
    char l_name[32];
  };
  typedef struct str_mlist str_mlist;
  struct str_list
  {
    SInt32 sl_nmods; 
    str_mlist *sl_modlist;
  };
  typedef struct str_list str_list;
  struct strpeek
  {
    strbuf ctlbuf;
    strbuf databuf;
    long flags; 
  };
  typedef struct strpeek strpeek;
  struct strpmsg
  {
    strbuf ctlbuf;
    strbuf databuf;
    SInt32 band;
    long flags;
  };
  typedef struct strpmsg strpmsg;
  struct strrecvfd
  {
    long fd;            
    unsigned short uid; 
    unsigned short gid;
    char fill[8];
  };
  typedef struct strrecvfd strrecvfd;
  struct strioctl
  {
    SInt32 ic_cmd;    
    SInt32 ic_timout; 
    SInt32 ic_len;    
    char *ic_dp;      
  };
  typedef struct strioctl strioctl;
  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,   
    SL_NOTIFY = 0x02,  
    SL_ERROR = 0x04,   
    SL_TRACE = 0x08,   
    SL_CONSOLE = 0x00, 
    SL_WARN = 0x20,    
    SL_NOTE = 0x40     
  };
 
  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
  };
 
#if CALL_NOT_IN_CARBON
 
  enum
  {
    T_BIND_REQ = 101,
    T_CONN_REQ = 102, 
    T_CONN_RES = 103, 
    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,          
    T_UREQUEST_REQ = 113,      
    T_REQUEST_REQ = 114,       
    T_UREPLY_REQ = 115,        
    T_REPLY_REQ = 116,         
    T_CANCELREQUEST_REQ = 117, 
    T_CANCELREPLY_REQ = 118,   
    T_REGNAME_REQ = 119,       
    T_DELNAME_REQ = 120,       
    T_LKUPNAME_REQ = 121,      
    T_BIND_ACK = 122,
    T_CONN_CON = 123, 
    T_CONN_IND = 124, 
    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,     
    T_UREQUEST_IND = 136, 
    T_REQUEST_IND = 137,  
    T_UREPLY_IND = 138,   
    T_REPLY_IND = 139,    
    T_UREPLY_ACK = 140,   
    T_REPLY_ACK = 141,    
    T_RESOLVEADDR_REQ = 142,
    T_RESOLVEADDR_ACK = 143,
 
    T_LKUPNAME_CON = 146,  
    T_LKUPNAME_RES = 147,  
    T_REGNAME_ACK = 148,   
    T_SEQUENCED_ACK = 149, 
    T_EVENT_IND = 160 
  };
 
  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
  };
 
  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; 
    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; 
  };
  typedef struct T_addr_req T_addr_req;
  struct T_bind_ack
  {
    long PRIM_type; 
    long ADDR_length;
    long ADDR_offset;
    unsigned long CONIND_number;
  };
  typedef struct T_bind_ack T_bind_ack;
  struct T_bind_req
  {
    long PRIM_type; 
    long ADDR_length;
    long ADDR_offset;
    unsigned long CONIND_number;
  };
  typedef struct T_bind_req T_bind_req;
  struct T_conn_con
  {
    long PRIM_type;  
    long RES_length; 
    long RES_offset;
    long OPT_length;
    long OPT_offset;
  };
  typedef struct T_conn_con T_conn_con;
  struct T_conn_ind
  {
    long PRIM_type; 
    long SRC_length;
    long SRC_offset;
    long OPT_length;
    long OPT_offset;
    long SEQ_number;
  };
  typedef struct T_conn_ind T_conn_ind;
  struct T_conn_req
  {
    long PRIM_type; 
    long DEST_length;
    long DEST_offset;
    long OPT_length;
    long OPT_offset;
  };
  typedef struct T_conn_req T_conn_req;
  struct T_conn_res
  {
    long PRIM_type; 
    queue_t *QUEUE_ptr;
    long OPT_length;
    long OPT_offset;
    long SEQ_number;
  };
  typedef struct T_conn_res T_conn_res;
  struct T_data_ind
  {
    long PRIM_type; 
    long MORE_flag;
  };
  typedef struct T_data_ind T_data_ind;
  struct T_data_req
  {
    long PRIM_type; 
    long MORE_flag;
  };
  typedef struct T_data_req T_data_req;
  struct T_discon_ind
  {
    long PRIM_type; 
    long DISCON_reason;
    long SEQ_number;
  };
  typedef struct T_discon_ind T_discon_ind;
  struct T_discon_req
  {
    long PRIM_type; 
    long SEQ_number;
  };
  typedef struct T_discon_req T_discon_req;
  struct T_exdata_ind
  {
    long PRIM_type; 
    long MORE_flag;
  };
  typedef struct T_exdata_ind T_exdata_ind;
  struct T_exdata_req
  {
    long PRIM_type; 
    long MORE_flag;
  };
  typedef struct T_exdata_req T_exdata_req;
  struct T_error_ack
  {
    long PRIM_type;  
    long ERROR_prim; 
    long TLI_error;
    long UNIX_error;
  };
  typedef struct T_error_ack T_error_ack;
  struct T_info_ack
  {
    long PRIM_type;     
    long TSDU_size;     
    long ETSDU_size;    
    long CDATA_size;    
    long DDATA_size;    
    long ADDR_size;     
    long OPT_size;      
    long TIDU_size;     
    long SERV_type;     
    long CURRENT_state; 
    long PROVIDER_flag; 
  };
  typedef struct T_info_ack T_info_ack;
  enum
  {
    SENDZERO = 0x0001, 
    XPG4_1 = 0x0002    
  };
 
  struct T_info_req
  {
    long PRIM_type; 
  };
  typedef struct T_info_req T_info_req;
  struct T_ok_ack
  {
    long PRIM_type; 
    long CORRECT_prim;
  };
  typedef struct T_ok_ack T_ok_ack;
  struct T_optmgmt_ack
  {
    long PRIM_type; 
    long OPT_length;
    long OPT_offset;
    long MGMT_flags;
  };
  typedef struct T_optmgmt_ack T_optmgmt_ack;
  struct T_optmgmt_req
  {
    long PRIM_type; 
    long OPT_length;
    long OPT_offset;
    long MGMT_flags;
  };
  typedef struct T_optmgmt_req T_optmgmt_req;
  struct T_ordrel_ind
  {
    long PRIM_type; 
  };
  typedef struct T_ordrel_ind T_ordrel_ind;
  struct T_ordrel_req
  {
    long PRIM_type; 
  };
  typedef struct T_ordrel_req T_ordrel_req;
  struct T_unbind_req
  {
    long PRIM_type; 
  };
  typedef struct T_unbind_req T_unbind_req;
  struct T_uderror_ind
  {
    long PRIM_type; 
    long DEST_length;
    long DEST_offset;
    long OPT_length;
    long OPT_offset;
    long ERROR_type;
  };
  typedef struct T_uderror_ind T_uderror_ind;
  struct T_unitdata_ind
  {
    long PRIM_type; 
    long SRC_length;
    long SRC_offset;
    long OPT_length;
    long OPT_offset;
  };
  typedef struct T_unitdata_ind T_unitdata_ind;
  struct T_unitdata_req
  {
    long PRIM_type; 
    long DEST_length;
    long DEST_offset;
    long OPT_length;
    long OPT_offset;
  };
  typedef struct T_unitdata_req T_unitdata_req;
  struct T_resolveaddr_ack
  {
    long PRIM_type; 
    long SEQ_number;
    long ADDR_length;
    long ADDR_offset;
    long ORIG_client;
    long ORIG_data;
    long TLI_error;
    long UNIX_error;
  };
  typedef struct T_resolveaddr_ack T_resolveaddr_ack;
  struct T_resolveaddr_req
  {
    long PRIM_type; 
    long SEQ_number;
    long ADDR_length;
    long ADDR_offset;
    long ORIG_client;
    long ORIG_data;
    long MAX_milliseconds;
  };
  typedef struct T_resolveaddr_req T_resolveaddr_req;
  struct T_unitreply_ind
  {
    long PRIM_type; 
    long SEQ_number;
    long OPT_length;
    long OPT_offset;
    long REP_flags;
    long TLI_error;
    long UNIX_error;
  };
  typedef struct T_unitreply_ind T_unitreply_ind;
  struct T_unitrequest_ind
  {
    long PRIM_type; 
    long SEQ_number;
    long SRC_length;
    long SRC_offset;
    long OPT_length;
    long OPT_offset;
    long REQ_flags;
  };
  typedef struct T_unitrequest_ind T_unitrequest_ind;
  struct T_unitrequest_req
  {
    long PRIM_type; 
    long SEQ_number;
    long DEST_length;
    long DEST_offset;
    long OPT_length;
    long OPT_offset;
    long REQ_flags;
  };
  typedef struct T_unitrequest_req T_unitrequest_req;
  struct T_unitreply_req
  {
    long PRIM_type; 
    long SEQ_number;
    long OPT_length;
    long OPT_offset;
    long REP_flags;
  };
  typedef struct T_unitreply_req T_unitreply_req;
  struct T_unitreply_ack
  {
    long PRIM_type; 
    long SEQ_number;
    long TLI_error;
    long UNIX_error;
  };
  typedef struct T_unitreply_ack T_unitreply_ack;
  struct T_cancelrequest_req
  {
    long PRIM_type; 
    long SEQ_number;
  };
  typedef struct T_cancelrequest_req T_cancelrequest_req;
  struct T_cancelreply_req
  {
    long PRIM_type; 
    long SEQ_number;
  };
  typedef struct T_cancelreply_req T_cancelreply_req;
  struct T_reply_ind
  {
    long PRIM_type; 
    long SEQ_number;
    long OPT_length;
    long OPT_offset;
    long REP_flags;
    long TLI_error;
    long UNIX_error;
  };
  typedef struct T_reply_ind T_reply_ind;
  struct T_request_ind
  {
    long PRIM_type; 
    long SEQ_number;
    long OPT_length;
    long OPT_offset;
    long REQ_flags;
  };
  typedef struct T_request_ind T_request_ind;
  struct T_request_req
  {
    long PRIM_type; 
    long SEQ_number;
    long OPT_length;
    long OPT_offset;
    long REQ_flags;
  };
  typedef struct T_request_req T_request_req;
  struct T_reply_req
  {
    long PRIM_type; 
    long SEQ_number;
    long OPT_length;
    long OPT_offset;
    long REP_flags;
  };
  typedef struct T_reply_req T_reply_req;
  struct T_reply_ack
  {
    long PRIM_type; 
    long SEQ_number;
    long TLI_error;
    long UNIX_error;
  };
  typedef struct T_reply_ack T_reply_ack;
  struct T_regname_req
  {
    long PRIM_type;  
    long SEQ_number; 
    long NAME_length;
    long NAME_offset;
    long ADDR_length;
    long ADDR_offset;
    long REQ_flags;
  };
  typedef struct T_regname_req T_regname_req;
  struct T_regname_ack
  {
    long PRIM_type; 
    long SEQ_number;
    long REG_id;
    long ADDR_length;
    long ADDR_offset;
  };
  typedef struct T_regname_ack T_regname_ack;
  struct T_delname_req
  {
    long PRIM_type;  
    long SEQ_number; 
    long NAME_length;
    long NAME_offset;
  };
  typedef struct T_delname_req T_delname_req;
  struct T_lkupname_req
  {
    long PRIM_type;   
    long SEQ_number;  
    long NAME_length; 
    long NAME_offset;
    long ADDR_length;
    long ADDR_offset;
    long MAX_number;
    long MAX_milliseconds;
    long REQ_flags;
  };
  typedef struct T_lkupname_req T_lkupname_req;
  struct T_lkupname_con
  {
    long PRIM_type;  
    long SEQ_number; 
    long NAME_length;
    long NAME_offset;
    long RSP_count;
    long RSP_cumcount;
  };
  typedef struct T_lkupname_con T_lkupname_con;
  struct T_sequence_ack
  {
    long PRIM_type; 
    long ORIG_prim; 
    long SEQ_number;
    long TLI_error;
    long UNIX_error;
  };
  typedef struct T_sequence_ack T_sequence_ack;
  struct T_event_ind
  {
    long PRIM_type; 
    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;
  enum
  {
    DL_CURRENT_VERSION = 0x02, 
    DL_VERSION_2 = 0x02        
  };
 
  enum
  {
    DL_INFO_REQ = 0x00,                
    DL_INFO_ACK = 0x03,                
    DL_ATTACH_REQ = 0x0B,              
    DL_DETACH_REQ = 0x0C,              
    DL_BIND_REQ = 0x01,                
    DL_BIND_ACK = 0x04,                
    DL_UNBIND_REQ = 0x02,              
    DL_OK_ACK = 0x06,                  
    DL_ERROR_ACK = 0x05,               
    DL_SUBS_BIND_REQ = 0x1B,           
    DL_SUBS_BIND_ACK = 0x1C,           
    DL_SUBS_UNBIND_REQ = 0x15,         
    DL_ENABMULTI_REQ = 0x1D,           
    DL_DISABMULTI_REQ = 0x1E,          
    DL_PROMISCON_REQ = 0x1F,           
    DL_PROMISCOFF_REQ = 0x20,          
    DL_UNITDATA_REQ = 0x07,            
    DL_UNITDATA_IND = 0x08,            
    DL_UDERROR_IND = 0x09,             
    DL_UDQOS_REQ = 0x0A,               
    DL_CONNECT_REQ = 0x0D,             
    DL_CONNECT_IND = 0x0E,             
    DL_CONNECT_RES = 0x0F,             
    DL_CONNECT_CON = 0x10,             
    DL_TOKEN_REQ = 0x11,               
    DL_TOKEN_ACK = 0x12,               
    DL_DISCONNECT_REQ = 0x13,          
    DL_DISCONNECT_IND = 0x14,          
    DL_RESET_REQ = 0x17,               
    DL_RESET_IND = 0x18,               
    DL_RESET_RES = 0x19,               
    DL_RESET_CON = 0x1A,               
    DL_DATA_ACK_REQ = 0x21,            
    DL_DATA_ACK_IND = 0x22,            
    DL_DATA_ACK_STATUS_IND = 0x23,     
    DL_REPLY_REQ = 0x24,               
    DL_REPLY_IND = 0x25,               
    DL_REPLY_STATUS_IND = 0x26,        
    DL_REPLY_UPDATE_REQ = 0x27,        
    DL_REPLY_UPDATE_STATUS_IND = 0x28, 
    DL_XID_REQ = 0x29,                 
    DL_XID_IND = 0x2A,                 
    DL_XID_RES = 0x2B,                 
    DL_XID_CON = 0x2C,                 
    DL_TEST_REQ = 0x2D,                
    DL_TEST_IND = 0x2E,                
    DL_TEST_RES = 0x2F,                
    DL_TEST_CON = 0x30,                
    DL_PHYS_ADDR_REQ = 0x31,           
    DL_PHYS_ADDR_ACK = 0x32,           
    DL_SET_PHYS_ADDR_REQ = 0x33,       
    DL_GET_STATISTICS_REQ = 0x34,      
    DL_GET_STATISTICS_ACK = 0x35       
  };
 
  enum
  {
    DL_UNATTACHED = 0x04,     
    DL_ATTACH_PENDING = 0x05, 
    DL_DETACH_PENDING = 0x06, 
    DL_UNBOUND = 0x00,        
    DL_BIND_PENDING = 0x01,   
    DL_UNBIND_PENDING =
        0x02,                   
    DL_IDLE = 0x03,             
    DL_UDQOS_PENDING = 0x07,    
    DL_OUTCON_PENDING = 0x08,   
    DL_INCON_PENDING = 0x09,    
    DL_CONN_RES_PENDING = 0x0A, 
    DL_DATAXFER = 0x0B,         
    DL_USER_RESET_PENDING =
        0x0C, 
    DL_PROV_RESET_PENDING =
        0x0D,                    
    DL_RESET_RES_PENDING = 0x0E, 
    DL_DISCON8_PENDING =
        0x0F, 
    DL_DISCON9_PENDING =
        0x10, 
    DL_DISCON11_PENDING =
        0x11, 
    DL_DISCON12_PENDING =
        0x12, 
    DL_DISCON13_PENDING =
        0x13,                 
    DL_SUBS_BIND_PND = 0x14,  
    DL_SUBS_UNBIND_PND = 0x15 
  };
 
  enum
  {
    DL_ACCESS = 0x02,      
    DL_BADADDR = 0x01,     
    DL_BADCORR = 0x05,     
    DL_BADDATA = 0x06,     
    DL_BADPPA = 0x08,      
    DL_BADPRIM = 0x09,     
    DL_BADQOSPARAM = 0x0A, 
    DL_BADQOSTYPE = 0x0B,  
    DL_BADSAP = 0x00,      
    DL_BADTOKEN = 0x0C,    
    DL_BOUND = 0x0D,       
    DL_INITFAILED = 0x0E,  
    DL_NOADDR = 0x0F,      
    DL_NOTINIT = 0x10,     
    DL_OUTSTATE =
        0x03,                
    DL_SYSERR = 0x04,        
    DL_UNSUPPORTED = 0x07,   
    DL_UNDELIVERABLE = 0x11, 
    DL_NOTSUPPORTED =
        0x12,          
    DL_TOOMANY = 0x13, 
    DL_NOTENAB = 0x14, 
    DL_BUSY =
        0x15, 
    DL_NOAUTO =
        0x16,             
    DL_NOXIDAUTO = 0x17,  
    DL_NOTESTAUTO = 0x18, 
    DL_XIDAUTO = 0x19,    
    DL_TESTAUTO = 0x1A,   
    DL_PENDING = 0x1B     
  };
 
  enum
  {
    DL_CSMACD = 0x00, 
    DL_TPB = 0x01,    
    DL_TPR = 0x02,    
    DL_METRO = 0x03,  
    DL_ETHER = 0x04,  
    DL_HDLC = 0x05,   
    DL_CHAR = 0x06,   
    DL_CTCA = 0x07,   
    DL_FDDI = 0x08,   
    DL_OTHER = 0x09   
  };
 
  enum
  {
    DL_CODLS = 0x01, 
    DL_CLDLS = 0x02, 
    DL_ACLDLS = 0x04 
  };
 
  enum
  {
    DL_STYLE1 = 0x0500, 
    DL_STYLE2 = 0x0501  
  };
 
  enum
  {
    DL_PROVIDER = 0x0700,
    DL_USER = 0x0701
  };
 
  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
  };
 
  enum
  {
    DL_RESET_FLOW_CONTROL = 0x0900,
    DL_RESET_LINK_ERROR = 0x0901,
    DL_RESET_RESYNCH = 0x0902
  };
 
  enum
  {
    DL_CMD_MASK = 0x0F, 
    DL_CMD_OK = 0x00,   
    DL_CMD_RS = 0x01,   
    DL_CMD_UE = 0x05,   
    DL_CMD_PE = 0x06,   
    DL_CMD_IP = 0x07,   
    DL_CMD_UN = 0x09,   
    DL_CMD_IT = 0x0F,   
    DL_RSP_MASK = 0xF0, 
    DL_RSP_OK = 0x00,   
    DL_RSP_RS = 0x10,   
    DL_RSP_NE = 0x30,   
    DL_RSP_NR = 0x40,   
    DL_RSP_UE = 0x50,   
    DL_RSP_IP = 0x70,   
    DL_RSP_UN = 0x90,   
    DL_RSP_IT = 0xF0    
  };
 
  enum
  {
    DL_RQST_RSP = 0x01,  
    DL_RQST_NORSP = 0x02 
  };
 
  enum
  {
    DL_FACT_PHYS_ADDR = 0x01, 
    DL_CURR_PHYS_ADDR = 0x02  
  };
 
  enum
  {
    DL_POLL_FINAL = 0x01 
  };
 
  enum
  {
    DL_AUTO_XID = 0x01, 
    DL_AUTO_TEST = 0x02 
  };
 
  enum
  {
    DL_PEER_BIND = 0x01,        
    DL_HIERARCHICAL_BIND = 0x02 
  };
 
  enum
  {
    DL_PROMISC_PHYS = 0x01, 
    DL_PROMISC_SAP = 0x02,  
    DL_PROMISC_MULTI = 0x03 
  };
 
#define DLIOCRAW MIOC_CMD(MIOC_DLPI, 1)
  struct dl_through_t
  {
    SInt32 dl_target_value; 
    SInt32 dl_accept_value; 
  };
  typedef struct dl_through_t dl_through_t;
  struct dl_transdelay_t
  {
    SInt32 dl_target_value; 
    SInt32 dl_accept_value; 
  };
  typedef struct dl_transdelay_t dl_transdelay_t;
  struct dl_priority_t
  {
    SInt32 dl_min;
    SInt32 dl_max;
  };
  typedef struct dl_priority_t dl_priority_t;
  enum
  {
    DL_NONE = 0x0B01,    
    DL_MONITOR = 0x0B02, 
    DL_MAXIMUM = 0x0B03  
  };
 
  struct dl_protect_t
  {
    SInt32 dl_min;
    SInt32 dl_max;
  };
  typedef struct dl_protect_t dl_protect_t;
  struct dl_resilience_t
  {
    SInt32 dl_disc_prob;  
    SInt32 dl_reset_prob; 
  };
  typedef struct dl_resilience_t dl_resilience_t;
  enum
  {
    DL_UNKNOWN = -1,
    DL_QOS_DONT_CARE = -2
  };
 
  enum
  {
    DL_QOS_CO_RANGE1 = 0x0101, 
    DL_QOS_CO_SEL1 = 0x0102,   
    DL_QOS_CL_RANGE1 = 0x0103, 
    DL_QOS_CL_SEL1 = 0x0104    
  };
 
  struct dl_qos_co_range1_t
  {
    UInt32 dl_qos_type;
    dl_through_t dl_rcv_throughput;     
    dl_transdelay_t dl_rcv_trans_delay; 
    dl_through_t dl_xmt_throughput;
    dl_transdelay_t dl_xmt_trans_delay;
    dl_priority_t dl_priority;  
    dl_protect_t dl_protection; 
    SInt32 dl_residual_error;
    dl_resilience_t dl_resilience;
  };
  typedef struct dl_qos_co_range1_t dl_qos_co_range1_t;
  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;
  struct dl_info_req_t
  {
    UInt32 dl_primitive; 
  };
  typedef struct dl_info_req_t dl_info_req_t;
  struct dl_info_ack_t
  {
    UInt32 dl_primitive;          
    UInt32 dl_max_sdu;            
    UInt32 dl_min_sdu;            
    UInt32 dl_addr_length;        
    UInt32 dl_mac_type;           
    UInt32 dl_reserved;           
    UInt32 dl_current_state;      
    SInt32 dl_sap_length;         
    UInt32 dl_service_mode;       
    UInt32 dl_qos_length;         
    UInt32 dl_qos_offset;         
    UInt32 dl_qos_range_length;   
    UInt32 dl_qos_range_offset;   
    UInt32 dl_provider_style;     
    UInt32 dl_addr_offset;        
    UInt32 dl_version;            
    UInt32 dl_brdcst_addr_length; 
    UInt32 dl_brdcst_addr_offset; 
    UInt32 dl_growth;             
  };
  typedef struct dl_info_ack_t dl_info_ack_t;
  struct dl_attach_req_t
  {
    UInt32 dl_primitive; 
    UInt32 dl_ppa;       
  };
  typedef struct dl_attach_req_t dl_attach_req_t;
  struct dl_detach_req_t
  {
    UInt32 dl_primitive; 
  };
  typedef struct dl_detach_req_t dl_detach_req_t;
  struct dl_bind_req_t
  {
    UInt32 dl_primitive;    
    UInt32 dl_sap;          
    UInt32 dl_max_conind;   
    UInt16 dl_service_mode; 
    UInt16 dl_conn_mgmt;    
    UInt32 dl_xidtest_flg;  
  };
  typedef struct dl_bind_req_t dl_bind_req_t;
  struct dl_bind_ack_t
  {
    UInt32 dl_primitive;   
    UInt32 dl_sap;         
    UInt32 dl_addr_length; 
    UInt32 dl_addr_offset; 
    UInt32 dl_max_conind;  
    UInt32 dl_xidtest_flg; 
  };
  typedef struct dl_bind_ack_t dl_bind_ack_t;
  struct dl_subs_bind_req_t
  {
    UInt32 dl_primitive;       
    UInt32 dl_subs_sap_offset; 
    UInt32 dl_subs_sap_length; 
    UInt32 dl_subs_bind_class; 
  };
  typedef struct dl_subs_bind_req_t dl_subs_bind_req_t;
  struct dl_subs_bind_ack_t
  {
    UInt32 dl_primitive;       
    UInt32 dl_subs_sap_offset; 
    UInt32 dl_subs_sap_length; 
  };
  typedef struct dl_subs_bind_ack_t dl_subs_bind_ack_t;
  struct dl_unbind_req_t
  {
    UInt32 dl_primitive; 
  };
  typedef struct dl_unbind_req_t dl_unbind_req_t;
  struct dl_subs_unbind_req_t
  {
    UInt32 dl_primitive;       
    UInt32 dl_subs_sap_offset; 
    UInt32 dl_subs_sap_length; 
  };
  typedef struct dl_subs_unbind_req_t dl_subs_unbind_req_t;
  struct dl_ok_ack_t
  {
    UInt32 dl_primitive;         
    UInt32 dl_correct_primitive; 
  };
  typedef struct dl_ok_ack_t dl_ok_ack_t;
  struct dl_error_ack_t
  {
    UInt32 dl_primitive;       
    UInt32 dl_error_primitive; 
    UInt32 dl_errno;           
    UInt32 dl_unix_errno;      
  };
  typedef struct dl_error_ack_t dl_error_ack_t;
  struct dl_enabmulti_req_t
  {
    UInt32 dl_primitive;   
    UInt32 dl_addr_length; 
    UInt32 dl_addr_offset; 
  };
  typedef struct dl_enabmulti_req_t dl_enabmulti_req_t;
  struct dl_disabmulti_req_t
  {
    UInt32 dl_primitive;   
    UInt32 dl_addr_length; 
    UInt32 dl_addr_offset; 
  };
  typedef struct dl_disabmulti_req_t dl_disabmulti_req_t;
  struct dl_promiscon_req_t
  {
    UInt32 dl_primitive; 
    UInt32 dl_level;     
  };
  typedef struct dl_promiscon_req_t dl_promiscon_req_t;
  struct dl_promiscoff_req_t
  {
    UInt32 dl_primitive; 
    UInt32 dl_level;     
  };
  typedef struct dl_promiscoff_req_t dl_promiscoff_req_t;
  struct dl_phys_addr_req_t
  {
    UInt32 dl_primitive; 
    UInt32 dl_addr_type; 
  };
  typedef struct dl_phys_addr_req_t dl_phys_addr_req_t;
  struct dl_phys_addr_ack_t
  {
    UInt32 dl_primitive;   
    UInt32 dl_addr_length; 
    UInt32 dl_addr_offset; 
  };
  typedef struct dl_phys_addr_ack_t dl_phys_addr_ack_t;
  struct dl_set_phys_addr_req_t
  {
    UInt32 dl_primitive;   
    UInt32 dl_addr_length; 
    UInt32 dl_addr_offset; 
  };
  typedef struct dl_set_phys_addr_req_t dl_set_phys_addr_req_t;
  struct dl_get_statistics_req_t
  {
    UInt32 dl_primitive; 
  };
  typedef struct dl_get_statistics_req_t dl_get_statistics_req_t;
  struct dl_get_statistics_ack_t
  {
    UInt32 dl_primitive;   
    UInt32 dl_stat_length; 
    UInt32 dl_stat_offset; 
  };
  typedef struct dl_get_statistics_ack_t dl_get_statistics_ack_t;
  struct dl_connect_req_t
  {
    UInt32 dl_primitive;        
    UInt32 dl_dest_addr_length; 
    UInt32 dl_dest_addr_offset; 
    UInt32 dl_qos_length;       
    UInt32 dl_qos_offset;       
    UInt32 dl_growth;           
  };
  typedef struct dl_connect_req_t dl_connect_req_t;
  struct dl_connect_ind_t
  {
    UInt32 dl_primitive;           
    UInt32 dl_correlation;         
    UInt32 dl_called_addr_length;  
    UInt32 dl_called_addr_offset;  
    UInt32 dl_calling_addr_length; 
    UInt32 dl_calling_addr_offset; 
    UInt32 dl_qos_length;          
    UInt32 dl_qos_offset;          
    UInt32 dl_growth;              
  };
  typedef struct dl_connect_ind_t dl_connect_ind_t;
  struct dl_connect_res_t
  {
    UInt32 dl_primitive;   
    UInt32 dl_correlation; 
    UInt32 dl_resp_token;  
    UInt32 dl_qos_length;  
    UInt32 dl_qos_offset;  
    UInt32 dl_growth;      
  };
  typedef struct dl_connect_res_t dl_connect_res_t;
  struct dl_connect_con_t
  {
    UInt32 dl_primitive;        
    UInt32 dl_resp_addr_length; 
    UInt32 dl_resp_addr_offset; 
    UInt32 dl_qos_length;       
    UInt32 dl_qos_offset;       
    UInt32 dl_growth;           
  };
  typedef struct dl_connect_con_t dl_connect_con_t;
  struct dl_token_req_t
  {
    UInt32 dl_primitive; 
  };
  typedef struct dl_token_req_t dl_token_req_t;
  struct dl_token_ack_t
  {
    UInt32 dl_primitive; 
    UInt32 dl_token;     
  };
  typedef struct dl_token_ack_t dl_token_ack_t;
  struct dl_disconnect_req_t
  {
    UInt32 dl_primitive;   
    UInt32 dl_reason;      
    UInt32 dl_correlation; 
  };
  typedef struct dl_disconnect_req_t dl_disconnect_req_t;
  struct dl_disconnect_ind_t
  {
    UInt32 dl_primitive;   
    UInt32 dl_originator;  
    UInt32 dl_reason;      
    UInt32 dl_correlation; 
  };
  typedef struct dl_disconnect_ind_t dl_disconnect_ind_t;
  struct dl_reset_req_t
  {
    UInt32 dl_primitive; 
  };
  typedef struct dl_reset_req_t dl_reset_req_t;
  struct dl_reset_ind_t
  {
    UInt32 dl_primitive;  
    UInt32 dl_originator; 
    UInt32 dl_reason;     
  };
  typedef struct dl_reset_ind_t dl_reset_ind_t;
  struct dl_reset_res_t
  {
    UInt32 dl_primitive; 
  };
  typedef struct dl_reset_res_t dl_reset_res_t;
  struct dl_reset_con_t
  {
    UInt32 dl_primitive; 
  };
  typedef struct dl_reset_con_t dl_reset_con_t;
  struct dl_unitdata_req_t
  {
    UInt32 dl_primitive;        
    UInt32 dl_dest_addr_length; 
    UInt32 dl_dest_addr_offset; 
    dl_priority_t dl_priority;  
  };
  typedef struct dl_unitdata_req_t dl_unitdata_req_t;
  struct dl_unitdata_ind_t
  {
    UInt32 dl_primitive;        
    UInt32 dl_dest_addr_length; 
    UInt32 dl_dest_addr_offset; 
    UInt32 dl_src_addr_length;  
    UInt32 dl_src_addr_offset;  
    UInt32 dl_group_address;    
  };
  typedef struct dl_unitdata_ind_t dl_unitdata_ind_t;
  struct dl_uderror_ind_t
  {
    UInt32 dl_primitive;        
    UInt32 dl_dest_addr_length; 
    UInt32 dl_dest_addr_offset; 
    UInt32 dl_unix_errno;       
    UInt32 dl_errno;            
  };
  typedef struct dl_uderror_ind_t dl_uderror_ind_t;
  struct dl_udqos_req_t
  {
    UInt32 dl_primitive;  
    UInt32 dl_qos_length; 
    UInt32 dl_qos_offset; 
  };
  typedef struct dl_udqos_req_t dl_udqos_req_t;
  struct dl_test_req_t
  {
    UInt32 dl_primitive;        
    UInt32 dl_flag;             
    UInt32 dl_dest_addr_length; 
    UInt32 dl_dest_addr_offset; 
  };
  typedef struct dl_test_req_t dl_test_req_t;
  struct dl_test_ind_t
  {
    UInt32 dl_primitive;        
    UInt32 dl_flag;             
    UInt32 dl_dest_addr_length; 
    UInt32 dl_dest_addr_offset; 
    UInt32 dl_src_addr_length;  
    UInt32 dl_src_addr_offset;  
  };
  typedef struct dl_test_ind_t dl_test_ind_t;
  struct dl_test_res_t
  {
    UInt32 dl_primitive;        
    UInt32 dl_flag;             
    UInt32 dl_dest_addr_length; 
    UInt32 dl_dest_addr_offset; 
  };
  typedef struct dl_test_res_t dl_test_res_t;
  struct dl_test_con_t
  {
    UInt32 dl_primitive;        
    UInt32 dl_flag;             
    UInt32 dl_dest_addr_length; 
    UInt32 dl_dest_addr_offset; 
    UInt32 dl_src_addr_length;  
    UInt32 dl_src_addr_offset;  
  };
  typedef struct dl_test_con_t dl_test_con_t;
  struct dl_xid_req_t
  {
    UInt32 dl_primitive;        
    UInt32 dl_flag;             
    UInt32 dl_dest_addr_length; 
    UInt32 dl_dest_addr_offset; 
  };
  typedef struct dl_xid_req_t dl_xid_req_t;
  struct dl_xid_ind_t
  {
    UInt32 dl_primitive;        
    UInt32 dl_flag;             
    UInt32 dl_dest_addr_length; 
    UInt32 dl_dest_addr_offset; 
    UInt32 dl_src_addr_length;  
    UInt32 dl_src_addr_offset;  
  };
  typedef struct dl_xid_ind_t dl_xid_ind_t;
  struct dl_xid_res_t
  {
    UInt32 dl_primitive;        
    UInt32 dl_flag;             
    UInt32 dl_dest_addr_length; 
    UInt32 dl_dest_addr_offset; 
  };
  typedef struct dl_xid_res_t dl_xid_res_t;
  struct dl_xid_con_t
  {
    UInt32 dl_primitive;        
    UInt32 dl_flag;             
    UInt32 dl_dest_addr_length; 
    UInt32 dl_dest_addr_offset; 
    UInt32 dl_src_addr_length;  
    UInt32 dl_src_addr_offset;  
  };
  typedef struct dl_xid_con_t dl_xid_con_t;
  struct dl_data_ack_req_t
  {
    UInt32 dl_primitive;        
    UInt32 dl_correlation;      
    UInt32 dl_dest_addr_length; 
    UInt32 dl_dest_addr_offset; 
    UInt32 dl_src_addr_length;  
    UInt32 dl_src_addr_offset;  
    UInt32 dl_priority;         
    UInt32 dl_service_class;    
  };
  typedef struct dl_data_ack_req_t dl_data_ack_req_t;
  struct dl_data_ack_ind_t
  {
    UInt32 dl_primitive;        
    UInt32 dl_dest_addr_length; 
    UInt32 dl_dest_addr_offset; 
    UInt32 dl_src_addr_length;  
    UInt32 dl_src_addr_offset;  
    UInt32 dl_priority;         
    UInt32 dl_service_class;    
  };
  typedef struct dl_data_ack_ind_t dl_data_ack_ind_t;
  struct dl_data_ack_status_ind_t
  {
    UInt32 dl_primitive;   
    UInt32 dl_correlation; 
    UInt32 dl_status;      
  };
  typedef struct dl_data_ack_status_ind_t dl_data_ack_status_ind_t;
  struct dl_reply_req_t
  {
    UInt32 dl_primitive;        
    UInt32 dl_correlation;      
    UInt32 dl_dest_addr_length; 
    UInt32 dl_dest_addr_offset; 
    UInt32 dl_src_addr_length;  
    UInt32 dl_src_addr_offset;  
    UInt32 dl_priority;         
    UInt32 dl_service_class;
  };
  typedef struct dl_reply_req_t dl_reply_req_t;
  struct dl_reply_ind_t
  {
    UInt32 dl_primitive;        
    UInt32 dl_dest_addr_length; 
    UInt32 dl_dest_addr_offset; 
    UInt32 dl_src_addr_length;  
    UInt32 dl_src_addr_offset;  
    UInt32 dl_priority;         
    UInt32 dl_service_class;    
  };
  typedef struct dl_reply_ind_t dl_reply_ind_t;
  struct dl_reply_status_ind_t
  {
    UInt32 dl_primitive;   
    UInt32 dl_correlation; 
    UInt32 dl_status;      
  };
  typedef struct dl_reply_status_ind_t dl_reply_status_ind_t;
  struct dl_reply_update_req_t
  {
    UInt32 dl_primitive;       
    UInt32 dl_correlation;     
    UInt32 dl_src_addr_length; 
    UInt32 dl_src_addr_offset; 
  };
  typedef struct dl_reply_update_req_t dl_reply_update_req_t;
  struct dl_reply_update_status_ind_t
  {
    UInt32 dl_primitive;   
    UInt32 dl_correlation; 
    UInt32 dl_status;      
  };
  typedef struct dl_reply_update_status_ind_t dl_reply_update_status_ind_t;
  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) 
  };
 
#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"
 
#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
  enum
  {
    kOTNoMessagesAvailable = (unsigned long)0xFFFFFFFF,
    kOTAnyMsgType = (unsigned long)0xFFFFFFFE,
    kOTDataMsgTypes = (unsigned long)0xFFFFFFFC,
    kOTMProtoMsgTypes = (unsigned long)0xFFFFFFFB,
    kOTOnlyMProtoMsgTypes = (unsigned long)0xFFFFFFFA
  };
 
#if !OTKERNEL
  typedef struct OpaqueStreamRef *StreamRef;
#define kOTInvalidStreamRef ((StreamRef)0L)
  struct PollRef
  {
    SInt32 filler; 
    SInt16 events;
    SInt16 revents;
    StreamRef ref;
  };
  typedef struct PollRef PollRef;
 
#define POLLIN 0x001  
#define POLLPRI 0x002 
#define POLLOUT 0x004 
#define POLLERR 0x008 
#define POLLHUP 0x010 
#define POLLNVAL \
  0x020 
#define POLLRDNORM \
  0x040 
#define POLLRDBAND \
  0x080 
#define POLLWRNORM \
  0x100 
#define POLLWRBAND \
  0x200               
#define POLLMSG 0x400 
  struct OTReadInfo
  {
    UInt32 fType;
    OTCommand fCommand;
    UInt32 fFiller; 
    ByteCount fBytes;
    OSStatus fError;
  };
  typedef struct OTReadInfo OTReadInfo;
#if CALL_NOT_IN_CARBON
  StreamRef
  OTStreamOpen(const char *name, OTOpenFlags oFlags, OSStatus *errPtr);
 
  OSStatus
  OTAsyncStreamOpen(const char *name, OTOpenFlags oFlags, OTNotifyUPP proc,
                    void *contextPtr);
 
  StreamRef
  OTCreateStream(OTConfigurationRef cfig, OTOpenFlags oFlags, OSStatus *errPtr);
 
  OSStatus
  OTAsyncCreateStream(OTConfigurationRef cfig, OTOpenFlags oFlags,
                      OTNotifyUPP proc, void *contextPtr);
 
  OSStatus
  OTStreamClose(StreamRef strm);
 
  OTResult
  OTStreamPoll(PollRef *fds, UInt32 nfds, OTTimeout timeout);
 
  OTResult
  OTAsyncStreamPoll(PollRef *fds, UInt32 nfds, OTTimeout timeout,
                    OTNotifyUPP proc, void *contextPtr);
 
  OTResult
  OTStreamRead(StreamRef strm, void *buf, OTByteCount len);
 
  OTResult
  OTStreamWrite(StreamRef strm, void *buf, OTByteCount len);
 
  OTResult
  OTStreamIoctl(StreamRef strm, UInt32 cmd, void *data);
 
  OTResult
  OTStreamPipe(StreamRef streamsToPipe[]);
 
  OSStatus
  OTStreamInstallNotifier(StreamRef strm, OTNotifyUPP proc, void *contextPtr);
 
  void
  OTStreamRemoveNotifier(StreamRef strm);
 
  OSStatus
  OTStreamUseSyncIdleEvents(StreamRef strm, Boolean useEvents);
 
  void
  OTStreamSetBlocking(StreamRef strm);
 
  void
  OTStreamSetNonBlocking(StreamRef strm);
 
  Boolean
  OTStreamIsBlocking(StreamRef strm);
 
  void
  OTStreamSetSynchronous(StreamRef strm);
 
  void
  OTStreamSetAsynchronous(StreamRef strm);
 
  Boolean
  OTStreamIsSynchronous(StreamRef strm);
 
  OTResult
  OTStreamGetMessage(StreamRef strm, strbuf *ctlbuf, strbuf *databuf,
                     OTFlags *flags);
 
  OTResult
  OTStreamGetPriorityMessage(StreamRef strm, strbuf *ctlbuf, strbuf *databuf,
                             OTBand *band, OTFlags *flags);
 
  OSStatus
  OTStreamPutMessage(StreamRef strm, const strbuf *ctlbuf, const strbuf *databuf,
                     OTFlags flags);
 
  OSStatus
  OTStreamPutPriorityMessage(StreamRef strm, const strbuf *ctlbuf,
                             const strbuf *databuf, OTBand band, OTFlags flags);
 
  void
  OTStreamSetControlMask(StreamRef strm, UInt32 mask, Boolean setClear);
 
  ProviderRef
  OTOpenProviderOnStream(StreamRef strm, OSStatus *errPtr);
 
  EndpointRef
  OTOpenEndpointOnStream(StreamRef strm, OSStatus *errPtr);
 
  StreamRef
  OTRemoveStreamFromProvider(ProviderRef ref);
 
  OSStatus
  OTPeekMessage(StreamRef strm, OTReadInfo *readInfo);
 
  OTBuffer *
  OTReadMessage(StreamRef strm, OTReadInfo *readInfo);
 
  void
  OTPutBackBuffer(StreamRef strm, OTBuffer *buffer);
 
  void
  OTPutBackPartialBuffer(StreamRef strm, OTBufferInfo *readInfo,
                         OTBuffer *buffer);
 
#endif 
#endif 
#endif 
#if !OTKERNEL
  struct OTPortCloseStruct
  {
    OTPortRef fPortRef;       
    ProviderRef fTheProvider; 
    OSStatus fDenyReason;     
  };
  typedef struct OTPortCloseStruct OTPortCloseStruct;
  struct OTClientList
  {
    ItemCount fNumClients;
    UInt8 fBuffer[4];
  };
  typedef struct OTClientList OTClientList;
#if CALL_NOT_IN_CARBON
  OSStatus
  OTYieldPortRequest(ProviderRef ref, OTPortRef portRef, OTClientList *buffer,
                     OTByteCount size);
 
  void
  OTNotifyAllClients(OTEventCode code, OTResult result, void *cookie);
 
  Boolean
  OTIsDependentPort(OTPortRef parent, OTPortRef child);
 
#endif 
#endif 
#if !OTKERNEL
 
  typedef long OTTimerTask;
  long
  OTCreateTimerTaskInContext(OTProcessUPP upp, void *arg,
                             OTClientContextPtr clientContext);
 
#if CALL_NOT_IN_CARBON
  OTTimerTask
  OTCreateTimerTask(OTProcessUPP proc, void *arg);
 
#endif 
  Boolean
  OTCancelTimerTask(OTTimerTask timerTask);
 
  void
  OTDestroyTimerTask(OTTimerTask timerTask);
 
  Boolean
  OTScheduleTimerTask(OTTimerTask timerTask, OTTimeout milliSeconds);
 
#if OTCARBONAPPLICATION
#define OTCreateTimerTask(upp, arg) OTCreateTimerTaskInContext(upp, arg, NULL)
#endif 
#endif 
#if !OTKERNEL
  OTByteCount
  OTBufferDataSize(OTBuffer *buffer);
 
  Boolean
  OTReadBuffer(OTBufferInfo *buffer, void *dest, OTByteCount *len);
 
  void
  OTReleaseBuffer(OTBuffer *buffer);
 
#if CALL_NOT_IN_CARBON
  Boolean
  StoreIntoNetbuf(TNetbuf *netBuf, void *source, SInt32 len);
 
  Boolean
  StoreMsgIntoNetbuf(TNetbuf *netBuf, OTBuffer *buffer);
 
#endif 
#endif 
#if CALL_NOT_IN_CARBON
#if !OTKERNEL
#if CALL_NOT_IN_CARBON
  OTConfigurationRef
  OTCfigNewConfiguration(const char *path);
 
  void
  OTCfigDeleteConfiguration(OTConfigurationRef cfig);
 
  OTConfigurationRef
  OTCfigCloneConfiguration(OTConfigurationRef cfig);
 
  OTConfigurationRef
  OTCfigPushNewSingleChild(OTConfigurationRef cfig, const char *path,
                           OSStatus *errPtr);
 
  OTConfigurationRef
  OTCfigPushParent(OTConfigurationRef cfig, const char *path, OSStatus *errPtr);
 
  OTConfigurationRef
  OTCfigPushChild(OTConfigurationRef cfig, OTItemCount index, const char *path,
                  OSStatus *errPtr);
 
  OSStatus
  OTCfigPopChild(OTConfigurationRef cfig, OTItemCount index);
 
  OTConfigurationRef
  OTCfigGetChild(OTConfigurationRef cfig, OTItemCount index);
 
  OSStatus
  OTCfigSetPath(OTConfigurationRef cfig, const char *path);
 
  OTConfigurationRef
  OTCfigNewChild(OTConfigurationRef cfig, const char *path, OSStatus *errPtr);
 
  OSStatus
  OTCfigAddChild(OTConfigurationRef cfig, OTConfigurationRef child);
 
  OTConfigurationRef
  OTCfigRemoveChild(OTConfigurationRef cfig, OTItemCount index);
 
  void
  OTCfigSetPortRef(OTConfigurationRef cfig, OTPortRef portRef);
 
  void
  OTCfigChangeProviderName(OTConfigurationRef cfig, const char *name);
 
  UInt16
  OTCfigNumberOfChildren(OTConfigurationRef cfig);
 
  OTConfigurationRef
  OTCfigGetParent(OTConfigurationRef cfig);
 
  TNetbuf *
  OTCfigGetOptionNetbuf(OTConfigurationRef cfig);
 
  OTPortRef
  OTCfigGetPortRef(OTConfigurationRef cfig);
 
  UInt32
  OTCfigGetInstallFlags(OTConfigurationRef cfig);
 
  const char *
  OTCfigGetProviderName(OTConfigurationRef cfig);
 
  Boolean
  OTCfigIsPort(OTConfigurationRef cfig);
 
#endif 
#endif 
#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
  enum
  {
    kOTSpecificConfigPass = 0,
    kOTGenericConfigPass = 1
  };
 
  typedef CALLBACK_API_C(Boolean, OTCanConfigureProcPtr)(OTConfigurationRef cfig,
                                                         UInt32 pass);
  typedef CALLBACK_API_C(OSStatus,
                         OTCreateConfiguratorProcPtr)(TOTConfiguratorRef *cfigor);
#define kOTSetupConfiguratorID "OTSetupConfigurator"
  enum
  {
    kOTDefaultConfigurator = 0,
    kOTProtocolFamilyConfigurator = 1,
    kOTLinkDriverConfigurator = 2
  };
 
  typedef CALLBACK_API_C(OSStatus, OTSetupConfiguratorProcPtr)(
      OTCanConfigureProcPtr *canConfigure,
      OTCreateConfiguratorProcPtr *createConfigurator, UInt8 *configuratorType);
  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);
#if CALL_NOT_IN_CARBON
  Boolean
  OTIsMasterConfigurator(TOTConfiguratorRef cfigor);
 
  void *
  OTGetConfiguratorUserData(TOTConfiguratorRef cfigor);
 
  TOTConfiguratorRef
  OTNewConfigurator(void *userData, OTCFConfigureProcPtr configure,
                    OTCFCreateStreamProcPtr createStream,
                    OTCFHandleSystemEventProcPtr handleEvent);
 
  void
  OTDeleteConfigurator(TOTConfiguratorRef cfigor);
 
  OSStatus
  OTNotifyUser(FSSpec *theFile, SInt32 rsrcID, OTItemCount index, char *parm1,
               char *parm2);
 
  void
  OTConfiguratorUnloaded(TOTConfiguratorRef cfigor);
 
  OSStatus
  OTCreateControlStream(OTConfigurationRef cfig, TOTConfiguratorRef cfigor,
                        OTNotifyUPP proc, void *contextPtr);
 
  OSStatus
  OTConfigureChildren(OTConfigurationRef cfig);
 
  UInt32
  OTNewControlMask(void);
 
  void
  OTCloseProvidersByUseCount(SInt32 *useCount, OTResult reason,
                             OTBooleanParam doneDeal);
 
  void
  OTCloseProvidersByPortRef(OTPortRef ref, OTResult reason,
                            OTBooleanParam doneDeal);
 
  void
  OTCloseProviderByStream(StreamRef ref, OTResult reason,
                          OTBooleanParam doneDeal);
 
  void
  OTCloseMatchingProviders(UInt32 mask, OTPortRef port, OTResult reason,
                           OTBooleanParam doneDeal);
 
#define kIsReliable 0x00000001
#define kIsNotReliable 0x00000002
#define kSupportsOrderlyRelease 0x00000004
 
#define kStream 0x0001
#define kUStream 0x0002
#define kTransaction 0x0004
#define kUTransaction 0x0008
#define kMapper 0x0010
#define kGenericProtocol 0x0020
 
#define kBooleanOption 0
#define kUnsignedValueOption 1
#define kSignedValueOption 2
#define kHexValueOption 3
#define kPrintableStringOption 4
#define kOctetStringOption 5
 
#define kTPIInterface 'TPI '
#define kDLPIInterface 'DLPI'
#define kMapperInterface 'MAPR'
#define kPrivateInterface -1
#define kNoInterface 0
 
#endif 
#endif 
#endif 
#if CALL_NOT_IN_CARBON
#if !OTKERNEL
#if TARGET_CPU_PPC
  typedef UInt8 OTStateMachineDataPad[12];
#else
  typedef UInt8 OTStateMachineDataPad[8];
#endif 
  typedef struct OTStateMachine OTStateMachine;
  typedef CALLBACK_API(void, OTStateProcPtr)(OTStateMachine *sm);
  typedef CALLBACK_API_C(void, OTSMCompleteProcPtr)(void *contextPtr);
  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))
#if CALL_NOT_IN_CARBON
  OTStateMachine *
  OTCreateStateMachine(void *buf, OTByteCount bufSize, OTByteCount structSize,
                       OTNotifyUPP proc, void *contextPtr);
 
  void
  OTDestroyStateMachine(OTStateMachine *sm);
 
  Boolean
  OTSMCallStateProc(OTStateMachine *sm, OTStateProcPtr proc, UInt32 state);
 
  UInt16
  OTSMGetState(OTStateMachine *sm);
 
  void
  OTSMSetState(OTStateMachine *sm, UInt32 state);
 
  void
  OTSMComplete(OTStateMachine *sm);
 
  void
  OTSMPopCallback(OTStateMachine *sm);
 
  Boolean
  OTSMWaitForComplete(OTStateMachine *sm);
 
  Boolean
  OTSMCreateStream(OTStateMachine *sm, OTConfigurationRef cfig,
                   OTOpenFlags flags);
 
  Boolean
  OTSMOpenStream(OTStateMachine *sm, const char *name, OTOpenFlags flags);
 
  Boolean
  OTSMIoctl(OTStateMachine *sm, StreamRef strm, UInt32 cmd, long data);
 
  Boolean
  OTSMPutMessage(OTStateMachine *sm, StreamRef strm, strbuf *ctlbuf,
                 strbuf *databuf, OTFlags flags);
 
  Boolean
  OTSMGetMessage(OTStateMachine *sm, StreamRef strm, strbuf *ctlbuf,
                 strbuf *databuf, OTFlags *flagsPtr);
 
  OSStatus
  OTSMReturnToCaller(OTStateMachine *sm);
 
  void *
  OTSMGetClientData(OTStateMachine *sm);
 
  void
  OTSMInstallCompletionProc(OTStateMachine *sm, OTSMCompleteProcPtr completeProc,
                            void *contextPtr);
 
  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 
#endif 
#define kSADModuleName "sad"
  enum
  {
    I_SAD_SAP = ((MIOC_SAD << 8) | 1), 
    I_SAD_GAP = ((MIOC_SAD << 8) | 2), 
    I_SAD_VML = ((MIOC_SAD << 8) |
                 3) 
  };
 
  enum
  {
    kOTAutopushMax = 8
  };
 
  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;
  enum
  {
    kSAP_ONE = 1,   
    kSAP_RANGE = 2, 
    kSAP_ALL = 3,   
    kSAP_CLEAR = 4  
  };
 
#define kPortConfigLibPrefix "OTPortCfg$"
 
#define kOTGetUserPortNameID "OTGetUserPortName"
  typedef CALLBACK_API_C(void, OTGetPortNameProcPtr)(OTPortRecord *port,
                                                     OTBooleanParam includeSlot,
                                                     OTBooleanParam includePort,
                                                     Str255 userVisibleName);
#define kOTGetPortIconID "OTGetPortIcon"
  struct OTResourceLocator
  {
    FSSpec fFile;
    UInt16 fResID;
  };
  typedef struct OTResourceLocator OTResourceLocator;
  typedef CALLBACK_API_C(Boolean,
                         OTGetPortIconProcPtr)(OTPortRecord *port,
                                               OTResourceLocator *iconLocation);
#if !OTKERNEL
#if CALL_NOT_IN_CARBON
  void
  OTGetUserPortNameFromPortRef(OTPortRef ref, Str255 friendlyName);
 
  Boolean
  OTGetPortIconFromPortRef(OTPortRef ref, OTResourceLocator *iconLocation);
 
#endif 
#if CALL_NOT_IN_CARBON
  Boolean
  OTIsPortCompatibleWith(const OTPortRecord *port, char *protocolName);
 
#endif 
#endif 
#endif 
  OTResult
  OTSetFirstClearBit(UInt8 *bitMap, OTByteCount startBit, OTByteCount numBits);
 
  Boolean
  OTClearBit(UInt8 *bitMap, OTByteCount bitNo);
 
  Boolean
  OTSetBit(UInt8 *bitMap, OTByteCount bitNo);
 
  Boolean
  OTTestBit(UInt8 *bitMap, OTByteCount bitNo);
 
  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;
#if CALL_NOT_IN_CARBON
  OTByteCount
  OTCalculateHashListMemoryNeeds(OTItemCount numEntries);
 
  OTResult
  OTInitHashList(void *memory, OTByteCount numBytes, OTHashProcPtr hashProc);
 
  void
  OTAddToHashList(OTHashList *hashList, OTLink *linkToAdd);
 
  Boolean
  OTRemoveLinkFromHashList(OTHashList *hashList, OTLink *linkToRemove);
 
  Boolean
  OTIsInHashList(OTHashList *hashList, OTLink *link);
 
  OTLink *
  OTFindInHashList(OTHashList *hashList, OTHashSearchProcPtr searchProc,
                   const void *refPtr, UInt32 hashValue);
 
  OTLink *
  OTRemoveFromHashList(OTHashList *hashList, OTHashSearchProcPtr searchProc,
                       const void *refPtr, UInt32 hashValue);
 
#endif 
#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
#if CALL_NOT_IN_CARBON
  UInt32
  OTGetRandomSeed(void);
 
  UInt32
  OTGetRandomNumber(UInt32 *seed, UInt32 lo, UInt32 hi);
 
#endif 
  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
  void
  OTInitGate(OTGate *gate, OTGateProcPtr proc);
 
  Boolean
  OTEnterGate(OTGate *gate, OTLink *withLink);
 
  Boolean
  OTLeaveGate(OTGate *gate);
 
#endif 
#if CALL_NOT_IN_CARBON
  enum
  {
    kOTGetDataSymbol = 0,
    kOTGetCodeSymbol = 1,
    kOTLoadNewCopy = 2,
    kOTLoadACopy = 4,
    kOTFindACopy = 8,
    kOTLibMask = kOTLoadNewCopy | kOTLoadACopy | kOTFindACopy,
    kOTLoadLibResident = 0x20
  };
 
  struct CFMLibraryInfo
  {
    OTLink link;        
    char *libName;      
    StringPtr intlName; 
    FSSpec *fileSpec;   
    StringPtr pstring2; 
    StringPtr pstring3; 
  };
  typedef struct CFMLibraryInfo CFMLibraryInfo;
  typedef CALLBACK_API_C(void *, OTAllocMemProcPtr)(OTByteCount size);
#if CALL_NOT_IN_CARBON
  OSStatus
  OTFindCFMLibraries(OSType libKind, const char *libType, OTList *theList,
                     OTAllocMemProcPtr allocator);
 
  OSStatus
  OTLoadCFMLibrary(const char *libName, UInt32 *connID, UInt32 loadFlags);
 
  void *
  OTGetCFMPointer(const char *libName, const char *entryName, UInt32 *connID,
                  UInt32 loadFlags);
 
  void *
  OTGetCFMSymbol(const char *entryName, UInt32 connID, UInt32 loadFlags);
 
  void
  OTReleaseCFMConnection(UInt32 *connID);
 
#endif 
#if !TARGET_CPU_68K
#if CALL_NOT_IN_CARBON
  OSStatus
  OTHoldThisCFMLibrary(const CFragInitBlock *initBlock);
 
  void
  OTUnholdThisCFMLibrary(void);
 
#endif 
#endif 
#if CALL_NOT_IN_CARBON
  OSStatus
  OTLoadASLMLibrary(const char *libName);
 
  void
  OTUnloadASLMLibrary(const char *libName);
 
  void
  UnloadUnusedLibraries(void);
 
#endif 
#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; }
};
 
#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 
#endif 
#endif 
#endif 
#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