You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4831 lines
142 KiB
4831 lines
142 KiB
/* |
|
File: OpenTransport.h |
|
|
|
Contains: Open Transport client interface file. |
|
|
|
Version: QuickTime 7.3 |
|
|
|
Copyright: (c) 2007 (c) 1985-2001 by Apple Computer, Inc., all rights reserved |
|
|
|
Bugs?: For bug reports, consult the following page on |
|
the World Wide Web: |
|
|
|
http://developer.apple.com/bugreporter/ |
|
|
|
*/ |
|
#ifndef __OPENTRANSPORT__ |
|
#define __OPENTRANSPORT__ |
|
|
|
|
|
|
|
|
|
/* |
|
The following table shows how to map from the old (pre-Universal |
|
Interfaces) header file name to the equivalent Universal Interfaces |
|
header file name. |
|
Old Header New Header |
|
---------- ---------- |
|
cred.h OpenTransportProtocol.h |
|
dlpi.h OpenTransportProtocol.h |
|
miioccom.h OpenTransportProtocol.h |
|
mistream.h OpenTransportProtocol.h/OpenTransportKernel.h |
|
modnames.h OpenTransportProtocol.h |
|
OpenTptAppleTalk.h OpenTransportProviders.h |
|
OpenTptClient.h OpenTransportProtocol.h |
|
OpenTptCommon.h OpenTransportProtocol.h |
|
OpenTptConfig.h OpenTransportProtocol.h |
|
OpenTptDevLinks.h OpenTransportProviders.h |
|
OpenTptInternet.h OpenTransportProviders.h |
|
OpenTptISDN.h OpenTransportProviders.h |
|
OpenTptLinks.h OpenTransportProviders.h |
|
OpenTptModule.h OpenTransportKernel.h |
|
OpenTptPCISupport.h OpenTransportKernel.h |
|
OpenTptSerial.h OpenTransportProviders.h |
|
OpenTptXTI.h OpenTransportUNIX.r |
|
OpenTransport.h OpenTransport.h |
|
OpenTransport.r OpenTransport.r |
|
OTConfig.r OpenTransportProtocol.r |
|
OTDebug.h OpenTransport.h |
|
OTSharedLibs.h OpenTransportProviders.h |
|
strlog.h OpenTransportProtocol.h/OpenTransportKernel.h |
|
stropts.h OpenTransportProtocol.h/OpenTransportUNIX.h |
|
strstat.h OpenTransportProtocol.h |
|
tihdr.h OpenTransportProtocol.h |
|
*/ |
|
|
|
#ifndef __MACTYPES__ |
|
#include <MacTypes.h> |
|
#endif |
|
|
|
#ifndef __MIXEDMODE__ |
|
#include <MixedMode.h> |
|
#endif |
|
|
|
#ifndef __MACERRORS__ |
|
#include <MacErrors.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. |
|
*/ |
|
|
|
#ifndef OTKERNEL |
|
#define OTKERNEL 0 |
|
#endif /* !defined(OTKERNEL) */ |
|
|
|
/* |
|
OTUNIXERRORS determines whether this file defines a bunch of |
|
common UNIX error codes, like EPERM. Typically, client code does |
|
not want to do this because of the possibility of a clash with |
|
other code modules, like the standard C libraries, that also |
|
defines these routines. However, client code can turn it on to |
|
get these definitions. This might be done by protocol stack |
|
infrastructure, or some other low-level code. |
|
"OpenTransportKernel.i" sets this flag before include |
|
"OpenTransport.h" because kernel modules typically need these |
|
error codes. Note that kernel modules shouldn't be including |
|
standard C libraries, so this is rarely a problem. |
|
In general, the clash between OT and standard C definitions |
|
of these error codes is rarely a problem becasue both OT |
|
and the C libraries define them to have the same value. But |
|
I'm sure this check is useful to some people. |
|
*/ |
|
#ifndef OTUNIXERRORS |
|
#define OTUNIXERRORS 0 |
|
#endif /* !defined(OTUNIXERRORS) */ |
|
|
|
/* |
|
OTDEBUG is used to control the behaviour of the OT debugging |
|
macros. If you set it to non-zero, the macros will generate code |
|
that drops you into the debugger. If you set it to 0, or leave it |
|
undefined, the macros are compiled out. |
|
Setting up this compiler variable is a little tricky because previous |
|
versions of the OT interfaces used a different variable, qDebug. |
|
We replaced qDebug with OTDEBUG because qDebug does not fit into |
|
the OT namespace. But I didn't want to break a lot of currently |
|
building code. The following tricky compiler variable footwork |
|
avoids this. |
|
There are four outcomes when this code is compiled, depending on |
|
whether qDebug and OTDEBUG are defined beforehand. The following |
|
table shows the outcome in each case. |
|
qDebug OTDEBUG Outcome Explanation |
|
------ ------- ------- ----------- |
|
defined defined OTDEBUG wins Mixed legacy and new code, we believe the new code. |
|
defined undefined qDebug wins Legacy code. |
|
undefined defined OTDEBUG wins New code. |
|
undefined undefined no debugging No debugging. |
|
*/ |
|
#ifdef qDebug |
|
#ifndef OTDEBUG |
|
#define OTDebug qDebug |
|
#endif /* !defined(OTDEBUG) */ |
|
|
|
#endif /* defined(qDebug) */ |
|
|
|
#ifndef OTDEBUG |
|
#define OTDEBUG 0 |
|
#endif /* !defined(OTDEBUG) */ |
|
|
|
/* Carbon Applications have some restrictions on using OT*/ |
|
#ifndef OTCARBONAPPLICATION |
|
#define OTCARBONAPPLICATION 0 |
|
#endif /* !defined(OTCARBONAPPLICATION) */ |
|
|
|
/* |
|
***** Normalise 68K Calling C Conventions ***** |
|
Define special types that handle the difference in parameter passing |
|
between different Mac OS C compilers when generating 68K code. OT |
|
exports C calling conventions routines, and various C compilers use |
|
various different conventions. Differences in the placement of the result |
|
are covered above, where we output pragma pointers_in_D0. The other big |
|
difference is how the compilers pass integer parameters less than 32 bits. |
|
The MPW compiler always extends these to 32 bits; other compilers simply |
|
push a value of the appropriate size. We overcome this difference by |
|
defining special OTFooParam types, which are only used when passing |
|
sub 32 bit values to routines. They are always defined to a 32 bit |
|
size, which makes all the compilers do the same thing. |
|
One weird consequence of this is that in more strict type checking |
|
languages (eg Pascal) OTBooleanParam is not compatible with Boolean. |
|
Sorry. |
|
*/ |
|
|
|
|
|
|
|
#if TARGET_CPU_68K |
|
typedef UInt32 OTUInt8Param; |
|
typedef UInt32 OTUInt16Param; |
|
typedef SInt32 OTSInt16Param; |
|
typedef SInt32 OTSInt8Param; |
|
typedef SInt32 OTBooleanParam; |
|
#else |
|
typedef UInt8 OTUInt8Param; |
|
typedef UInt16 OTUInt16Param; |
|
typedef SInt16 OTSInt16Param; |
|
typedef SInt8 OTSInt8Param; |
|
typedef Boolean OTBooleanParam; |
|
#endif /* TARGET_CPU_68K */ |
|
|
|
|
|
#if defined(__MWERKS__) || defined(THINK_C) || defined(SYMANTEC_CPLUS) || defined(SYMANTEC_C) || defined (__xlc) || defined (__xlC) || defined (__xlC__) |
|
typedef ByteCount OTByteCount; |
|
typedef ItemCount OTItemCount; |
|
typedef SInt32 OTInt32; |
|
typedef UInt32 OTUInt32; |
|
#else |
|
typedef unsigned int OTByteCount; |
|
typedef unsigned int OTItemCount; |
|
typedef int OTInt32; |
|
typedef unsigned int OTUInt32; |
|
#endif |
|
|
|
/* ***** C++ Support ******/ |
|
|
|
/* |
|
Setup _MDECL to be _cdecl when compiling C++ code with |
|
compilers that support it, or nothing otherwise. |
|
*/ |
|
|
|
|
|
|
|
#define _MDECL |
|
#if defined(__SC__) || defined(THINK_CPLUS) || defined(__MRC__) |
|
#ifdef __cplusplus |
|
#undef _MDECL |
|
#define _MDECL _cdecl |
|
#endif |
|
#endif |
|
|
|
/* ***** Shared Library Prefixes ******/ |
|
|
|
|
|
#define kOTLibraryVersion "1.1" |
|
|
|
#define kOTLibraryPrefix "OTLib$" |
|
#define kOTModulePrefix "OTModl$" |
|
#define kOTClientPrefix "OTClnt$" |
|
#define kOTKernelPrefix "OTKrnl$" |
|
|
|
enum { |
|
kOTCFMClass = FOUR_CHAR_CODE('otan') |
|
}; |
|
|
|
/* ***** Miscellaneous Type Definitions ******/ |
|
|
|
/* A millisecond timeout value*/ |
|
typedef UInt32 OTTimeout; |
|
/* An ID number in connections/transactions */ |
|
typedef SInt32 OTSequence; |
|
/* An ID number for registered names */ |
|
typedef SInt32 OTNameID; |
|
/* |
|
A protocol-specific reason code for failure. |
|
Usually a Unix-style positive error code. |
|
*/ |
|
typedef SInt32 OTReason; |
|
/* Number of outstanding connection requests at a time.*/ |
|
typedef UInt32 OTQLen; |
|
/* Will become internationalizeable shortly (yeah, right).*/ |
|
typedef UInt8 * OTClientName; |
|
/* The command code in STREAMS messages.*/ |
|
typedef SInt32 OTCommand; |
|
/* value describing a client*/ |
|
typedef struct OpaqueOTClient* OTClient; |
|
|
|
/* |
|
OT now defines its own version of the standard C "offsetof" |
|
macro so as to avoid including <stddef.h>. |
|
*/ |
|
#define OTOffsetOf(structure,field) ((ByteCount)&((structure *) 0)->field) |
|
|
|
/* ***** Debugging Macros ******/ |
|
|
|
|
|
#define kOTFatalErr "FB " |
|
#define kOTNonfatalErr "NB " |
|
#define kOTExtFatalErr "FX " |
|
#define kOTExtNonfatalErr "NX " |
|
#define kOTUserFatalErr "UF " |
|
#define kOTUserErr "UE " |
|
#define kOTUserNonfatalErr "UE " |
|
#define kOTInfoErr "IE " |
|
#define kOTInfoBreak "IN " |
|
|
|
|
|
#if CALL_NOT_IN_CARBON |
|
/* |
|
* OTDebugStr() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( void ) |
|
OTDebugStr(const char * str); |
|
|
|
|
|
|
|
#if qDebug > 0 |
|
#define OTDebugBreak(str) OTDebugStr(str) |
|
#define OTDebugTest(val, str) { if ( val ) OTDebugStr(str); } |
|
#define OTAssert(name, cond) ((cond) ? ((void) 0) : (OTDebugStr( __FILE__ ": " #name ": " #cond ))) |
|
#else |
|
#define OTDebugBreak(str) |
|
#define OTDebugTest(val, str) |
|
#define OTAssert(name, cond) |
|
#endif /* qDebug > 0 */ |
|
|
|
#if qDebug > 1 || qDebug2 > 1 |
|
#define OTDebugBreak2(str) OTDebugStr(str) |
|
#define OTDebugTest2(val, str) { if ( val) OTDebugStr(str); } |
|
#else |
|
#define OTDebugBreak2(str) |
|
#define OTDebugTest2(val, str) |
|
#endif /* qDebug > 1 || qDebug2 > 1 */ |
|
|
|
#endif /* CALL_NOT_IN_CARBON */ |
|
|
|
/* |
|
***** Flags Used When Opening Providers ***** |
|
Important |
|
OT does not currently support any of these flags. You should |
|
always pass 0 to a parameter of type OTOpenFlags. If you need |
|
to modify the mode of operation of a provider, use OTSetBlocking, |
|
OTSetSynchronous, etc. |
|
*/ |
|
typedef UInt32 OTOpenFlags; |
|
enum { |
|
kO_ASYNC = 0x01, |
|
kO_NDELAY = 0x04, |
|
kO_NONBLOCK = 0x04 |
|
}; |
|
|
|
|
|
#if CALL_NOT_IN_CARBON |
|
/* |
|
BSD defines O_ASYNC, O_NDELAY and O_NONBLOCK in fcntl.h |
|
Use kO_ASYNC, kO_NDELAY and kO_NONBLOCK in the unlikely event you need the OT value in Carbon |
|
*/ |
|
enum { |
|
O_ASYNC = kO_ASYNC, |
|
O_NDELAY = kO_NDELAY, |
|
O_NONBLOCK = kO_NONBLOCK |
|
}; |
|
|
|
#endif /* CALL_NOT_IN_CARBON */ |
|
|
|
/* ***** UNIX-Style Error Codes ******/ |
|
|
|
typedef UInt16 OTUnixErr; |
|
/* |
|
These definitions are only compiled if you're building kernel code |
|
or you explicit request them by setting OTUNIXERRORS. See the |
|
description of these compiler variables, given above. |
|
*/ |
|
#if OTKERNEL || OTUNIXERRORS |
|
/* |
|
There may be some error code confusions with other compiler vendor header |
|
files - However, these match both MPW and AIX definitions. |
|
*/ |
|
/* |
|
First we undefine the #defined ones we know about so that we can put them |
|
in an enum. Of course, this is only going to work in C, but hopefully |
|
other languages won't have these symbols overloaded. |
|
*/ |
|
|
|
|
|
#undef EPERM |
|
#undef ENOENT |
|
#undef ENORSRC |
|
#undef EINTR |
|
#undef EIO |
|
#undef ENXIO |
|
#undef E2BIG |
|
#undef EBADF |
|
#undef EAGAIN |
|
#undef ENOMEM |
|
#undef EACCES |
|
#undef EFAULT |
|
#undef EBUSY |
|
#undef EEXIST |
|
#undef ENODEV |
|
#undef EINVAL |
|
#undef ENOTTY |
|
#undef ERANGE |
|
#undef ESRCH |
|
#undef EPIPE |
|
|
|
enum { |
|
EPERM = 1, /* Permission denied */ |
|
ENOENT = 2, /* No such file or directory */ |
|
ENORSRC = 3, /* No such resource */ |
|
EINTR = 4, /* Interrupted system service */ |
|
EIO = 5, /* I/O error */ |
|
ENXIO = 6, /* No such device or address */ |
|
EBADF = 9, /* Bad file number */ |
|
EAGAIN = 11, /* Try operation again later */ |
|
ENOMEM = 12, /* Not enough space */ |
|
EACCES = 13, /* Permission denied */ |
|
EFAULT = 14, /* Bad address */ |
|
EBUSY = 16, /* Device or resource busy */ |
|
EEXIST = 17, /* File exists */ |
|
ENODEV = 19, /* No such device */ |
|
EINVAL = 22, /* Invalid argument */ |
|
ENOTTY = 25, /* Not a character device */ |
|
EPIPE = 32, /* Broken pipe */ |
|
ERANGE = 34, /* Math result not representable */ |
|
EDEADLK = 35, /* Call would block so was aborted */ |
|
EWOULDBLOCK = 35, /* Or a deadlock would occur */ |
|
EALREADY = 37, |
|
ENOTSOCK = 38, /* Socket operation on non-socket */ |
|
EDESTADDRREQ = 39, /* Destination address required */ |
|
EMSGSIZE = 40, /* Message too long */ |
|
EPROTOTYPE = 41, /* Protocol wrong type for socket */ |
|
ENOPROTOOPT = 42, /* Protocol not available */ |
|
EPROTONOSUPPORT = 43, /* Protocol not supported */ |
|
ESOCKTNOSUPPORT = 44, /* Socket type not supported */ |
|
EOPNOTSUPP = 45, /* Operation not supported on socket */ |
|
EADDRINUSE = 48, /* Address already in use */ |
|
EADDRNOTAVAIL = 49, /* Can't assign requested address */ |
|
ENETDOWN = 50, /* Network is down */ |
|
ENETUNREACH = 51, /* Network is unreachable */ |
|
ENETRESET = 52, /* Network dropped connection on reset */ |
|
ECONNABORTED = 53, /* Software caused connection abort */ |
|
ECONNRESET = 54, /* Connection reset by peer */ |
|
ENOBUFS = 55, /* No buffer space available */ |
|
EISCONN = 56, /* Socket is already connected */ |
|
ENOTCONN = 57, /* Socket is not connected */ |
|
ESHUTDOWN = 58, /* Can't send after socket shutdown */ |
|
ETOOMANYREFS = 59, /* Too many references: can't splice */ |
|
ETIMEDOUT = 60, /* Connection timed out */ |
|
ECONNREFUSED = 61, /* Connection refused */ |
|
EHOSTDOWN = 64, /* Host is down */ |
|
EHOSTUNREACH = 65, /* No route to host */ |
|
EPROTO = 70, /* STREAMS protocol error */ |
|
ETIME = 71, |
|
ENOSR = 72, |
|
EBADMSG = 73, |
|
ECANCEL = 74, |
|
ENOSTR = 75, |
|
ENODATA = 76, |
|
EINPROGRESS = 77, |
|
ESRCH = 78, |
|
ENOMSG = 79, |
|
ELASTERRNO = 79 |
|
}; |
|
|
|
#endif /* OTKERNEL || OTUNIXERRORS */ |
|
|
|
/* ***** Open Transport/XTI Error codes ******/ |
|
typedef UInt16 OTXTIErr; |
|
enum { |
|
TSUCCESS = 0, /* No Error occurred */ |
|
TBADADDR = 1, /* A Bad address was specified */ |
|
TBADOPT = 2, /* A Bad option was specified */ |
|
TACCES = 3, /* Missing access permission */ |
|
TBADF = 4, /* Bad provider reference */ |
|
TNOADDR = 5, /* No address was specified */ |
|
TOUTSTATE = 6, /* Call issued in wrong state */ |
|
TBADSEQ = 7, /* Sequence specified does not exist */ |
|
TSYSERR = 8, /* A system error occurred */ |
|
TLOOK = 9, /* An event occurred - call Look() */ |
|
TBADDATA = 10, /* An illegal amount of data was specified */ |
|
TBUFOVFLW = 11, /* Passed buffer not big enough */ |
|
TFLOW = 12, /* Provider is flow-controlled */ |
|
TNODATA = 13, /* No data available for reading */ |
|
TNODIS = 14, /* No disconnect indication available */ |
|
TNOUDERR = 15, /* No Unit Data Error indication available */ |
|
TBADFLAG = 16, /* A Bad flag value was supplied */ |
|
TNOREL = 17, /* No orderly release indication available */ |
|
TNOTSUPPORT = 18, /* Command is not supported */ |
|
TSTATECHNG = 19, /* State is changing - try again later */ |
|
TNOSTRUCTYPE = 20, /* Bad structure type requested for OTAlloc */ |
|
TBADNAME = 21, /* A bad endpoint name was supplied */ |
|
TBADQLEN = 22, /* A Bind to an in-use address with qlen > 0*/ |
|
TADDRBUSY = 23, /* Address requested is already in use */ |
|
TINDOUT = 24, /* Accept failed because of pending listen */ |
|
TPROVMISMATCH = 25, /* Tried to accept on incompatible endpoint */ |
|
TRESQLEN = 26, |
|
TRESADDR = 27, |
|
TQFULL = 28, |
|
TPROTO = 29, /* An unspecified provider error occurred */ |
|
TBADSYNC = 30, /* A synchronous call at interrupt time */ |
|
TCANCELED = 31, /* The command was cancelled */ |
|
TLASTXTIERROR = 31 |
|
}; |
|
|
|
/* |
|
***** Mac OS Error Codes ***** |
|
Most OT client routines return an OSStatus error code, a 32 bit type |
|
defined in "MacTypes.h". The OT-unique error code values are |
|
defined below. Many of these are generated by remapping XTI error |
|
codes (Txxxx) and UNIX error codes (Exxxx) to a reserved range |
|
in the OSStatus space. |
|
Some routines return an OTResult type, indicating |
|
that the routine might fail with a negative error, succeed with noErr, |
|
or possible return a positive value indicating some status. |
|
*/ |
|
|
|
typedef SInt32 OTResult; |
|
|
|
/* |
|
* These map the Open Transport/XTI errors (the Txxxx error codes), and the |
|
* StdCLib Exxxx error codes into unique spaces in the Mac OS OSStatus space. |
|
*/ |
|
#define XTI2OSStatus(x) (-3149 - (x)) |
|
#define E2OSStatus(x) (-3199 - (x)) |
|
|
|
#define OSStatus2XTI(x) ((OTXTIErr)(-3149 - (x))) |
|
#define OSStatus2E(x) ((OTUnixErr)(-3199 - (x))) |
|
|
|
#define IsXTIError(x) ((x) < -3149 && (x) >= (-3149 - TLASTXTIERROR)) |
|
#define IsEError(x) ((x) < -3199 && (x) >= (-3199 - ELASTERRNO)) |
|
|
|
/* ***** OTAddress ******/ |
|
|
|
/* |
|
OTAddress type defines the standard header for all OT address formats. |
|
It consists of one 16 bit integer, which defines the address format |
|
used, followed by an arbitrary number of bytes which are protocol-specific. |
|
Conceptually, all OT address formats are subtypes of this type, |
|
extended with fields that are specific to the protocol. For example, |
|
OTInetAddress starts with the OTAddressType field and then continues |
|
to include a host IP address and a port number. |
|
*/ |
|
|
|
enum { |
|
kOTGenericName = 0 /* Protocol specific data is just a string, interpreted in a protocol-specific fashion.*/ |
|
}; |
|
|
|
typedef UInt16 OTAddressType; |
|
struct OTAddress { |
|
OTAddressType fAddressType; /* The address format of this address...*/ |
|
UInt8 fAddress[1]; /* ... followed by protocol specific address information.*/ |
|
}; |
|
typedef struct OTAddress OTAddress; |
|
/* |
|
***** OTAlloc Constants ***** |
|
Note: |
|
In general, Apple recommends that you avoid the OTAlloc call because |
|
using it extensively causes your program to allocate and deallocate |
|
many memory blocks, with each extra memory allocation costing time. |
|
*/ |
|
/* |
|
OTStructType defines the structure type to be allocated using the OTAlloc |
|
call. |
|
*/ |
|
enum { |
|
T_BIND = 1, |
|
T_OPTMGMT = 2, |
|
T_CALL = 3, |
|
T_DIS = 4, |
|
T_UNITDATA = 5, |
|
T_UDERROR = 6, |
|
T_INFO = 7, |
|
T_REPLYDATA = 8, |
|
T_REQUESTDATA = 9, |
|
T_UNITREQUEST = 10, |
|
T_UNITREPLY = 11 |
|
}; |
|
|
|
|
|
typedef UInt32 OTStructType; |
|
/* |
|
These values are used in the "fields" parameter of the OTAlloc call |
|
to define which fields of the structure should be allocated. |
|
*/ |
|
enum { |
|
T_ADDR = 0x01, |
|
T_OPT = 0x02, |
|
T_UDATA = 0x04, |
|
T_ALL = 0xFFFF |
|
}; |
|
|
|
typedef UInt32 OTFieldsType; |
|
/* ***** OTFlags ******/ |
|
/* |
|
This type is used to describe bitwise flags in OT data structures |
|
and parameters. Think of it as the OT analogue to the OptionBits |
|
type in "MacTypes.h". |
|
*/ |
|
|
|
typedef UInt32 OTFlags; |
|
/* |
|
These flags are used when sending and receiving data. The |
|
constants defined are masks. |
|
*/ |
|
enum { |
|
T_MORE = 0x0001, /* More data to come in message */ |
|
T_EXPEDITED = 0x0002, /* Data is expedited, if possible */ |
|
T_ACKNOWLEDGED = 0x0004, /* Acknowledge transaction */ |
|
T_PARTIALDATA = 0x0008, /* Partial data - more coming */ |
|
T_NORECEIPT = 0x0010, /* No event on transaction done */ |
|
T_TIMEDOUT = 0x0020 /* Reply timed out */ |
|
}; |
|
|
|
/* These flags are used in the TOptMgmt structure to request services.*/ |
|
|
|
enum { |
|
T_NEGOTIATE = 0x0004, |
|
T_CHECK = 0x0008, |
|
T_DEFAULT = 0x0010, |
|
T_CURRENT = 0x0080 |
|
}; |
|
|
|
/* |
|
These flags are used in the TOptMgmt and TOption structures to |
|
return results. |
|
*/ |
|
|
|
enum { |
|
T_SUCCESS = 0x0020, |
|
T_FAILURE = 0x0040, |
|
T_PARTSUCCESS = 0x0100, |
|
T_READONLY = 0x0200, |
|
T_NOTSUPPORT = 0x0400 |
|
}; |
|
|
|
/* |
|
***** OTBand ***** |
|
A band is a STREAMS concepts which defines the priority of data |
|
on a stream. Although this type is defined as a 32 bit number |
|
for efficiency's sake, bands actually only range from 0 to 255. |
|
Typically band 0 is used for normal data and band 1 for expedited data. |
|
*/ |
|
typedef UInt32 OTBand; |
|
/* ***** Object References ******/ |
|
/* |
|
This deserves some explanation. If you're compiling for |
|
C++, the C++ definitions of TEndpoint and TMapper at the |
|
end of this file are invoked, which lets the compiler |
|
know that they are both subclasses of TProvider. This |
|
way the compiler will do the right subclass type checking, |
|
ie you will be able to pass an EndpointRef to a parameter |
|
of type ProviderRef, but not vice versa. |
|
On the other hand, if your compiling for straighth C, |
|
everything is defined as void. This is somewhat dangerous, |
|
but it prevents you have to cast an EndpointRef to a |
|
ProviderRef every time you call a function that works |
|
on all forms of providers. |
|
*/ |
|
#ifdef __cplusplus |
|
typedef class TProvider* ProviderRef; |
|
typedef class TEndpoint* EndpointRef; |
|
typedef class TMapper* MapperRef; |
|
#else |
|
typedef void* ProviderRef; |
|
typedef void* EndpointRef; |
|
typedef void* MapperRef; |
|
#endif |
|
#define kOTInvalidRef 0L |
|
#define kOTInvalidProviderRef ((ProviderRef)0L) |
|
#define kOTInvalidEndpointRef ((EndpointRef)0L) |
|
#define kOTInvalidMapperRef ((MapperRef)0L) |
|
/* ***** Event Codes ******/ |
|
/* |
|
OT event codes values for Open Transport. These are the event codes that |
|
are sent to notification routine (notifiers). |
|
*/ |
|
|
|
typedef UInt32 OTEventCode; |
|
/* |
|
Events are divided into numerous categories: |
|
|
|
1. (0x0000xxxx) The core XTI events have identifiers of the form |
|
T_XXXX. These signal that an XTI event has occured on a stream. |
|
2. (0x1000xxxx) Private events are reserved for protocol specific |
|
events. Each protocol stack defines them as appropriate for |
|
its own usage. |
|
3. (0x2000xxxxx) Completion events have identifiers of the form |
|
T_XXXXCOMPLETE. These signal the completion of some asynchronous |
|
API routine, and are only delivered if the endpoint is in asynchronous |
|
mode. |
|
4. (0x2100xxxx) Stream events are generally encountered when programming |
|
the raw streams API and indicate some event on a raw stream, or |
|
some other event of interest in the STREAMS kernel. |
|
5. (0x2200xxxx) Signal events indicate that a signal has arrived on |
|
a raw stream. See "Signal Values" for details. |
|
6. (0x2300xxxx) General provider events that might be generated by any |
|
provider. |
|
7. (0x2400xxxx) System events sent to all providers. |
|
8. (0x2500xxxx) System events sent to registered clients. |
|
9. (0x2600xxxx) System events used by configurators. |
|
10. (0x2700xxxx) Events sent to registered OT clients. |
|
*/ |
|
/* |
|
All event codes not described here are reserved by Apple. If you receive |
|
an event code you do not understand, ignore it! |
|
*/ |
|
|
|
enum { |
|
T_LISTEN = 0x0001, /* An connection request is available */ |
|
T_CONNECT = 0x0002, /* Confirmation of a connect request */ |
|
T_DATA = 0x0004, /* Standard data is available */ |
|
T_EXDATA = 0x0008, /* Expedited data is available */ |
|
T_DISCONNECT = 0x0010, /* A disconnect is available */ |
|
T_ERROR = 0x0020, /* obsolete/unused in library */ |
|
T_UDERR = 0x0040, /* A Unit Data Error has occurred */ |
|
T_ORDREL = 0x0080, /* An orderly release is available */ |
|
T_GODATA = 0x0100, /* Flow control lifted on standard data */ |
|
T_GOEXDATA = 0x0200, /* Flow control lifted on expedited data*/ |
|
T_REQUEST = 0x0400, /* An Incoming request is available */ |
|
T_REPLY = 0x0800, /* An Incoming reply is available */ |
|
T_PASSCON = 0x1000, /* State is now T_DATAXFER */ |
|
T_RESET = 0x2000, /* Protocol has been reset */ |
|
kPRIVATEEVENT = 0x10000000, /* Base of the private event range.*/ |
|
kCOMPLETEEVENT = 0x20000000, /* Base of the completion event range.*/ |
|
T_BINDCOMPLETE = 0x20000001, /* Bind call is complete */ |
|
T_UNBINDCOMPLETE = 0x20000002, /* Unbind call is complete */ |
|
T_ACCEPTCOMPLETE = 0x20000003, /* Accept call is complete */ |
|
T_REPLYCOMPLETE = 0x20000004, /* SendReply call is complete */ |
|
T_DISCONNECTCOMPLETE = 0x20000005, /* Disconnect call is complete */ |
|
T_OPTMGMTCOMPLETE = 0x20000006, /* OptMgmt call is complete */ |
|
T_OPENCOMPLETE = 0x20000007, /* An Open call is complete */ |
|
T_GETPROTADDRCOMPLETE = 0x20000008, /* GetProtAddress call is complete */ |
|
T_RESOLVEADDRCOMPLETE = 0x20000009, /* A ResolveAddress call is complet */ |
|
T_GETINFOCOMPLETE = 0x2000000A, /* A GetInfo call is complete */ |
|
T_SYNCCOMPLETE = 0x2000000B, /* A Sync call is complete */ |
|
T_MEMORYRELEASED = 0x2000000C, /* No-copy memory was released */ |
|
T_REGNAMECOMPLETE = 0x2000000D, /* A RegisterName call is complete */ |
|
T_DELNAMECOMPLETE = 0x2000000E, /* A DeleteName call is complete */ |
|
T_LKUPNAMECOMPLETE = 0x2000000F, /* A LookupName call is complete */ |
|
T_LKUPNAMERESULT = 0x20000010, /* A LookupName is returning a name */ |
|
kOTSyncIdleEvent = 0x20000011, /* Synchronous call Idle event */ |
|
kSTREAMEVENT = 0x21000000, /* Base of the raw stream event range.*/ |
|
kOTReservedEvent1 = 0x21000001, /* reserved for internal use by OT */ |
|
kGetmsgEvent = 0x21000002, /* A GetMessage call is complete */ |
|
kStreamReadEvent = 0x21000003, /* A Read call is complete */ |
|
kStreamWriteEvent = 0x21000004, /* A Write call is complete */ |
|
kStreamIoctlEvent = 0x21000005, /* An Ioctl call is complete */ |
|
kOTReservedEvent2 = 0x21000006, /* reserved for internal use by OT */ |
|
kStreamOpenEvent = 0x21000007, /* An OpenStream call is complete */ |
|
kPollEvent = 0x21000008, /* A Poll call is complete */ |
|
kOTReservedEvent3 = 0x21000009, /* reserved for internal use by OT */ |
|
kOTReservedEvent4 = 0x2100000A, /* reserved for internal use by OT */ |
|
kOTReservedEvent5 = 0x2100000B, /* reserved for internal use by OT */ |
|
kOTReservedEvent6 = 0x2100000C, /* reserved for internal use by OT */ |
|
kOTReservedEvent7 = 0x2100000D, /* reserved for internal use by OT */ |
|
kOTReservedEvent8 = 0x2100000E, /* reserved for internal use by OT */ |
|
kSIGNALEVENT = 0x22000000, /* A signal has arrived on a raw stream, see "Signal Values" below.*/ |
|
kPROTOCOLEVENT = 0x23000000, /* Some event from the protocols */ |
|
kOTProviderIsDisconnected = 0x23000001, /* Provider is temporarily off-line */ |
|
kOTProviderIsReconnected = 0x23000002, /* Provider is now back on-line */ |
|
kOTProviderWillClose = 0x24000001, /* Provider will close immediately */ |
|
kOTProviderIsClosed = 0x24000002, /* Provider was closed */ |
|
kOTPortDisabled = 0x25000001, /* Port is now disabled, result is 0, cookie is port ref */ |
|
kOTPortEnabled = 0x25000002, /* Port is now enabled, result is 0, cookie is port ref */ |
|
kOTPortOffline = 0x25000003, /* Port is now offline, result is 0, cookie is port ref */ |
|
kOTPortOnline = 0x25000004, /* Port is now online, result is 0, cookie is port ref */ |
|
kOTClosePortRequest = 0x25000005, /* Request to close/yield, result is reason, cookie is OTPortCloseStruct* */ |
|
kOTYieldPortRequest = 0x25000005, /* Request to close/yield, result is reason, cookie is OTPortCloseStruct* */ |
|
kOTNewPortRegistered = 0x25000006, /* New port has been registered, cookie is port ref */ |
|
kOTPortNetworkChange = 0x25000007, /* Port may have moved to a new network, result is 0, cookie is port ref */ |
|
kOTConfigurationChanged = 0x26000001, /* Protocol configuration changed */ |
|
kOTSystemSleep = 0x26000002, |
|
kOTSystemShutdown = 0x26000003, |
|
kOTSystemAwaken = 0x26000004, |
|
kOTSystemIdle = 0x26000005, |
|
kOTSystemSleepPrep = 0x26000006, |
|
kOTSystemShutdownPrep = 0x26000007, |
|
kOTSystemAwakenPrep = 0x26000008, |
|
kOTStackIsLoading = 0x27000001, /* Sent before Open Transport attempts to load the TCP/IP protocol stack.*/ |
|
kOTStackWasLoaded = 0x27000002, /* Sent after the TCP/IP stack has been successfully loaded.*/ |
|
kOTStackIsUnloading = 0x27000003 /* Sent before Open Transport unloads the TCP/IP stack.*/ |
|
}; |
|
|
|
|
|
|
|
|
|
/* ***** Event Classification Macros ***** */ |
|
|
|
#define IsOTPrivateEvent(x) (((x) & 0x70000000L) == kPRIVATEEVENT) |
|
#define IsOTCompleteEvent(x) (((x) & 0x7f000000L) == kCOMPLETEEVENT) |
|
#define IsOTProtocolEvent(x) (((x) & 0x7f000000L) == kPROTOCOLEVENT) |
|
#define IsOTStreamEvent(x) (((x) & 0x7f000000L) == kSTREAMEVENT) |
|
#define IsOTSignalEvent(x) (((x) & 0x7f000000L) == kSIGNALEVENT) |
|
#define GetOTEventCode(x) (x) |
|
|
|
/* |
|
***** Signal Values ***** |
|
Signals that are generated by a raw stream. When writing a notifier |
|
for a raw stream, add these values to kSIGNALEVENT to determine what |
|
event you are receiving. |
|
*/ |
|
|
|
enum { |
|
kSIGHUP = 1, |
|
kSIGURG = 16, |
|
kSIGPOLL = 30 |
|
}; |
|
|
|
enum { |
|
SIGHUP = kSIGHUP, |
|
SIGURG = kSIGURG, |
|
SIGPOLL = kSIGPOLL |
|
}; |
|
|
|
|
|
/* |
|
***** Notifier Type Definition ***** |
|
Open Transport notifiers must conform to the OTNotifyProcPtr prototype. |
|
Even though a OTNotifyUPP is a OTNotifyProcPtr on pre-Carbon system, |
|
use NewOTNotifyUPP() and friends to make your source code portable to OS X and Carbon. |
|
*/ |
|
typedef CALLBACK_API( void , OTNotifyProcPtr )(void *contextPtr, OTEventCode code, OTResult result, void *cookie); |
|
typedef TVECTOR_UPP_TYPE(OTNotifyProcPtr) OTNotifyUPP; |
|
/* |
|
* NewOTNotifyUPP() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: available as macro/inline |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API_C( OTNotifyUPP ) |
|
NewOTNotifyUPP(OTNotifyProcPtr userRoutine); |
|
#if !OPAQUE_UPP_TYPES |
|
enum { uppOTNotifyProcInfo = 0x00003FC0 }; /* pascal no_return_value Func(4_bytes, 4_bytes, 4_bytes, 4_bytes) */ |
|
#ifdef __cplusplus |
|
inline DEFINE_API_C(OTNotifyUPP) NewOTNotifyUPP(OTNotifyProcPtr userRoutine) { return userRoutine; } |
|
#else |
|
#define NewOTNotifyUPP(userRoutine) (userRoutine) |
|
#endif |
|
#endif |
|
|
|
/* |
|
* DisposeOTNotifyUPP() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: available as macro/inline |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API_C( void ) |
|
DisposeOTNotifyUPP(OTNotifyUPP userUPP); |
|
#if !OPAQUE_UPP_TYPES |
|
#ifdef __cplusplus |
|
inline DEFINE_API_C(void) DisposeOTNotifyUPP(OTNotifyUPP) {} |
|
#else |
|
#define DisposeOTNotifyUPP(userUPP) |
|
#endif |
|
#endif |
|
|
|
/* |
|
* InvokeOTNotifyUPP() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: available as macro/inline |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API_C( void ) |
|
InvokeOTNotifyUPP( |
|
void * contextPtr, |
|
OTEventCode code, |
|
OTResult result, |
|
void * cookie, |
|
OTNotifyUPP userUPP); |
|
#if !OPAQUE_UPP_TYPES |
|
#ifdef __cplusplus |
|
inline DEFINE_API_C(void) InvokeOTNotifyUPP(void * contextPtr, OTEventCode code, OTResult result, void * cookie, OTNotifyUPP userUPP) { (*userUPP)(contextPtr, code, result, cookie); } |
|
#else |
|
#define InvokeOTNotifyUPP(contextPtr, code, result, cookie, userUPP) (*userUPP)(contextPtr, code, result, cookie) |
|
#endif |
|
#endif |
|
|
|
/* ***** Option Management Definitions ******/ |
|
/* The XTI Level number of a protocol.*/ |
|
enum { |
|
XTI_GENERIC = 0xFFFF /* level for XTI options */ |
|
}; |
|
|
|
typedef UInt32 OTXTILevel; |
|
/* The XTI name of a protocol option.*/ |
|
typedef UInt32 OTXTIName; |
|
/* XTI names for options used with XTI_GENERIC above*/ |
|
enum { |
|
XTI_DEBUG = 0x0001, |
|
XTI_LINGER = 0x0080, |
|
XTI_RCVBUF = 0x1002, |
|
XTI_RCVLOWAT = 0x1004, |
|
XTI_SNDBUF = 0x1001, |
|
XTI_SNDLOWAT = 0x1003, |
|
XTI_PROTOTYPE = 0x1005, |
|
OPT_CHECKSUM = 0x0600, /* Set checksumming = UInt32 - 0 or 1)*/ |
|
OPT_RETRYCNT = 0x0601, /* Set a retry counter = UInt32 (0 = infinite)*/ |
|
OPT_INTERVAL = 0x0602, /* Set a retry interval = UInt32 milliseconds*/ |
|
OPT_ENABLEEOM = 0x0603, /* Enable the EOM indication = UInt8 (0 or 1)*/ |
|
OPT_SELFSEND = 0x0604, /* Enable Self-sending on broadcasts = UInt32 (0 or 1)*/ |
|
OPT_SERVERSTATUS = 0x0605, /* Set Server Status (format is proto dependent)*/ |
|
OPT_ALERTENABLE = 0x0606, /* Enable/Disable protocol alerts*/ |
|
OPT_KEEPALIVE = 0x0008 /* See t_keepalive structure*/ |
|
}; |
|
|
|
/* ***** Ioctl Definitions ******/ |
|
|
|
/* |
|
All OT ioctl numbers are formed using the MIOC_CMD macro, |
|
which divides the ioctl space by protocol space (the |
|
first parameter) and ioctl number within that protocol |
|
space (the second parameter). This macro is only available |
|
to C users but it's relatively easy to synthesise its |
|
results in other languages. |
|
*/ |
|
#define MIOC_CMD(t,v) ((((t)&0xFF) << 8) | ((v)&0xFF)) |
|
|
|
/* The following is a registry of the ioctls protocol spaces.*/ |
|
|
|
enum { |
|
MIOC_STREAMIO = 'A', /* Basic Stream ioctl() cmds - I_PUSH, I_LOOK, etc. */ |
|
MIOC_TMOD = 'a', /* ioctl's for tmod test module */ |
|
MIOC_STRLOG = 'b', /* ioctl's for Mentat's log device */ |
|
MIOC_ND = 'c', /* ioctl's for Mentat's nd device */ |
|
MIOC_ECHO = 'd', /* ioctl's for Mentat's echo device */ |
|
MIOC_TLI = 'e', /* ioctl's for Mentat's timod module */ |
|
MIOC_RESERVEDf = 'f', /* reserved, used by SVR4 FIOxxx */ |
|
MIOC_SAD = 'g', /* ioctl's for Mentat's sad module */ |
|
MIOC_ARP = 'h', /* ioctl's for Mentat's arp module */ |
|
MIOC_HAVOC = 'H', /* Havoc module ioctls. */ |
|
MIOC_RESERVEDi = 'i', /* reserved, used by SVR4 SIOCxxx */ |
|
MIOC_SIOC = 'j', /* sockio.h socket ioctl's */ |
|
MIOC_TCP = 'k', /* tcp.h ioctl's */ |
|
MIOC_DLPI = 'l', /* dlpi.h additions */ |
|
MIOC_SOCKETS = 'm', /* Mentat sockmod ioctl's */ |
|
MIOC_IPX = 'o', /* ioctls for IPX */ |
|
MIOC_OT = 'O', /* ioctls for Open Transport */ |
|
MIOC_ATALK = 'T', /* ioctl's for AppleTalk */ |
|
MIOC_SRL = 'U', /* ioctl's for Serial */ |
|
MIOC_RESERVEDp = 'p', /* reserved, used by SVR4 */ |
|
MIOC_RESERVEDr = 'r', /* reserved, used by SVR4 */ |
|
MIOC_RESERVEDs = 's', /* reserved, used by SVR4 */ |
|
MIOC_CFIG = 'z' /* ioctl's for private configuration */ |
|
}; |
|
|
|
/* OT specific ioctls.*/ |
|
|
|
enum { |
|
I_OTGetMiscellaneousEvents = ((MIOC_OT << 8) | 1), /* sign up for Misc Events */ |
|
I_OTSetFramingType = ((MIOC_OT << 8) | 2), /* Set framing option for link */ |
|
kOTGetFramingValue = (unsigned long)0xFFFFFFFF, /* Use this value to read framing */ |
|
I_OTSetRawMode = ((MIOC_OT << 8) | 3), /* Set raw mode for link */ |
|
kOTSetRecvMode = 0x01, |
|
kOTSendErrorPacket = 0x02, |
|
I_OTConnect = ((MIOC_OT << 8) | 4), /* Generic connect request for links */ |
|
I_OTDisconnect = ((MIOC_OT << 8) | 5), /* Generic disconnect request for links */ |
|
I_OTScript = ((MIOC_OT << 8) | 6) /* Send a script to a module */ |
|
}; |
|
|
|
/* Structure for the I_OTScript Ioctl.*/ |
|
|
|
struct OTScriptInfo { |
|
UInt32 fScriptType; |
|
void * fTheScript; |
|
UInt32 fScriptLength; |
|
}; |
|
typedef struct OTScriptInfo OTScriptInfo; |
|
/* |
|
***** XTI States ***** |
|
These are the potential values returned by OTGetEndpointState and OTSync |
|
which represent the XTI state of an endpoint. |
|
*/ |
|
typedef UInt32 OTXTIStates; |
|
enum { |
|
T_UNINIT = 0, /* addition to standard xti.h */ |
|
T_UNBND = 1, /* unbound */ |
|
T_IDLE = 2, /* idle */ |
|
T_OUTCON = 3, /* outgoing connection pending */ |
|
T_INCON = 4, /* incoming connection pending */ |
|
T_DATAXFER = 5, /* data transfer */ |
|
T_OUTREL = 6, /* outgoing orderly release */ |
|
T_INREL = 7 /* incoming orderly release */ |
|
}; |
|
|
|
/* |
|
***** General XTI Definitions ***** |
|
These definitions are typically used during option management. |
|
*/ |
|
|
|
enum { |
|
T_YES = 1, |
|
T_NO = 0, |
|
T_UNUSED = (unsigned long)(-1), |
|
kT_NULL = 0, |
|
T_ABSREQ = 0x8000 |
|
}; |
|
|
|
enum { |
|
kT_UNSPEC = (unsigned long)0xFFFFFFFD, |
|
T_ALLOPT = 0 |
|
}; |
|
|
|
enum { |
|
T_NULL = kT_NULL, |
|
T_UNSPEC = kT_UNSPEC |
|
}; |
|
|
|
/* |
|
***** OTConfiguration ***** |
|
This is a "black box" structure used to define the configuration of a |
|
provider or endpoint. This file defines a very limited set of operations |
|
on a configuration. "OpenTransportClient.h" extends this with extra |
|
operations used by protocol stacks but not typically needed by clients. |
|
*/ |
|
|
|
|
|
#ifdef __cplusplus |
|
typedef class OTConfiguration* OTConfigurationRef; |
|
#else |
|
typedef struct OTConfiguration* OTConfigurationRef; |
|
#endif |
|
#define kOTNoMemoryConfigurationPtr ((OTConfigurationRef)0L) |
|
#define kOTInvalidConfigurationPtr ((OTConfigurationRef)-1L) |
|
/* ***** Option Management Structures ******/ |
|
|
|
/* This structure describes the contents of a single option in a buffer.*/ |
|
|
|
struct TOptionHeader { |
|
ByteCount len; /* total length of option */ |
|
/* = sizeof(TOptionHeader) + length */ |
|
/* of option value in bytes */ |
|
OTXTILevel level; /* protocol affected */ |
|
OTXTIName name; /* option name */ |
|
UInt32 status; /* status value */ |
|
}; |
|
typedef struct TOptionHeader TOptionHeader; |
|
/* |
|
This structure describes the contents of a single option in a buffer. |
|
It differs from TOptionHeader in that it includes the value field, |
|
which acts as an unbounded array representing the value of the option. |
|
*/ |
|
struct TOption { |
|
ByteCount len; /* total length of option */ |
|
/* = sizeof(TOption) + length */ |
|
/* of option value in bytes */ |
|
OTXTILevel level; /* protocol affected */ |
|
OTXTIName name; /* option name */ |
|
UInt32 status; /* status value */ |
|
UInt32 value[1]; /* data goes here */ |
|
}; |
|
typedef struct TOption TOption; |
|
/* Some useful constants when manipulating option buffers.*/ |
|
enum { |
|
kOTOptionHeaderSize = sizeof(TOptionHeader), |
|
kOTBooleanOptionDataSize = sizeof(UInt32), |
|
kOTBooleanOptionSize = kOTOptionHeaderSize + kOTBooleanOptionDataSize, |
|
kOTOneByteOptionSize = kOTOptionHeaderSize + 1, |
|
kOTTwoByteOptionSize = kOTOptionHeaderSize + 2, |
|
kOTFourByteOptionSize = kOTOptionHeaderSize + sizeof(UInt32) |
|
}; |
|
|
|
|
|
/* |
|
This macro will align return the value of "len", rounded up to the next |
|
4-byte boundary. |
|
*/ |
|
|
|
#define T_ALIGN(len) (((UInt32)(len)+(sizeof(SInt32)-1)) & ~(sizeof(SInt32)-1)) |
|
|
|
/* |
|
This macro will return the next option in the buffer, given the previous option |
|
in the buffer, returning NULL if there are no more. |
|
You start off by setting prevOption = (TOption*)theBuffer |
|
(Use OTNextOption for a more thorough check - it ensures the end |
|
of the option is in the buffer as well.) |
|
*/ |
|
|
|
#define OPT_NEXTHDR(theBuffer, theBufLen, prevOption) \ |
|
(((char*)(prevOption) + T_ALIGN((prevOption)->len) < (char*)(theBuffer) + (theBufLen)) ? \ |
|
(TOption*)((char*)(prevOption)+T_ALIGN((prevOption)->len)) \ |
|
: (TOption*)NULL) |
|
|
|
|
|
/* t_kpalive is used with OPT_KEEPALIVE option.*/ |
|
|
|
struct t_kpalive { |
|
SInt32 kp_onoff; /* option on/off */ |
|
SInt32 kp_timeout; /* timeout in minutes */ |
|
}; |
|
typedef struct t_kpalive t_kpalive; |
|
/* t_linger is used with XTI_LINGER option.*/ |
|
struct t_linger { |
|
SInt32 l_onoff; /* option on/off */ |
|
SInt32 l_linger; /* linger time */ |
|
}; |
|
typedef struct t_linger t_linger; |
|
/* |
|
***** TEndpointInfo ***** |
|
This structure is returned from the GetEndpointInfo call and contains |
|
information about an endpoint. But first, some special flags and types. |
|
*/ |
|
/* Values returned in servtype field of TEndpointInfo.*/ |
|
|
|
typedef UInt32 OTServiceType; |
|
enum { |
|
T_COTS = 1, /* Connection-mode service */ |
|
T_COTS_ORD = 2, /* Connection service with orderly release */ |
|
T_CLTS = 3, /* Connectionless-mode service */ |
|
T_TRANS = 5, /* Connection-mode transaction service */ |
|
T_TRANS_ORD = 6, /* Connection transaction service with orderly release */ |
|
T_TRANS_CLTS = 7 /* Connectionless transaction service */ |
|
}; |
|
|
|
/* Masks for the flags field of TEndpointInfo.*/ |
|
|
|
enum { |
|
T_SENDZERO = 0x0001, /* supports 0-length TSDU's */ |
|
T_XPG4_1 = 0x0002, /* supports the GetProtAddress call */ |
|
T_CAN_SUPPORT_MDATA = 0x10000000, /* support M_DATAs on packet protocols */ |
|
T_CAN_RESOLVE_ADDR = 0x40000000, /* Supports ResolveAddress call */ |
|
T_CAN_SUPPLY_MIB = 0x20000000 /* Supports SNMP MIB data */ |
|
}; |
|
|
|
/* |
|
Special-case values for in the tsdu, etsdu, connect, and discon |
|
fields of TEndpointInfo. |
|
*/ |
|
|
|
enum { |
|
T_INFINITE = -1, /* supports infinit amounts of data */ |
|
T_INVALID = -2 /* Does not support data transmission */ |
|
}; |
|
|
|
|
|
typedef SInt32 OTDataSize; |
|
/* Now the TEndpointInfo structure proper.*/ |
|
struct TEndpointInfo { |
|
OTDataSize addr; /* Maximum size of an address */ |
|
OTDataSize options; /* Maximum size of options */ |
|
OTDataSize tsdu; /* Standard data transmit unit size */ |
|
OTDataSize etsdu; /* Expedited data transmit unit size */ |
|
OTDataSize connect; /* Maximum data size on connect */ |
|
OTDataSize discon; /* Maximum data size on disconnect */ |
|
OTServiceType servtype; /* service type */ |
|
UInt32 flags; /* Flags (see above for values) */ |
|
}; |
|
typedef struct TEndpointInfo TEndpointInfo; |
|
/* |
|
"OpenTransport.h" no longer defines "struct t_info". We recommend |
|
that you use TEndpointInfo instead. If this is impossible, use |
|
the definition of "struct t_info" in "OpenTransportXTI.h". |
|
*/ |
|
/* ***** OTPortRecord ******/ |
|
|
|
/* Unique identifier for a port.*/ |
|
|
|
|
|
typedef UInt32 OTPortRef; |
|
typedef OTPortRef * OTPortRefPtr; |
|
enum { |
|
kOTInvalidPortRef = 0 |
|
}; |
|
|
|
/* Valid values for the bus type element of an OTPortRef.*/ |
|
|
|
typedef UInt8 OTBusType; |
|
enum { |
|
kOTUnknownBusPort = 0, |
|
kOTMotherboardBus = 1, |
|
kOTNuBus = 2, |
|
kOTPCIBus = 3, |
|
kOTGeoPort = 4, |
|
kOTPCCardBus = 5, |
|
kOTFireWireBus = 6, |
|
kOTLastBusIndex = 15 |
|
}; |
|
|
|
/* |
|
A couple of special values for the device type element of an |
|
OTPortRef. See "OpenTransportDevices.h" for the standard values. |
|
*/ |
|
|
|
typedef UInt16 OTDeviceType; |
|
enum { |
|
kOTNoDeviceType = 0, |
|
kOTADEVDevice = 1, /* An Atalk ADEV */ |
|
kOTMDEVDevice = 2, /* A TCP/IP MDEV */ |
|
kOTLocalTalkDevice = 3, /* LocalTalk */ |
|
kOTIRTalkDevice = 4, /* IRTalk */ |
|
kOTTokenRingDevice = 5, /* Token Ring */ |
|
kOTISDNDevice = 6, /* ISDN */ |
|
kOTATMDevice = 7, /* ATM */ |
|
kOTSMDSDevice = 8, /* SMDS */ |
|
kOTSerialDevice = 9, /* Serial */ |
|
kOTEthernetDevice = 10, /* Ethernet */ |
|
kOTSLIPDevice = 11, /* SLIP Pseudo-device */ |
|
kOTPPPDevice = 12, /* PPP Pseudo-device */ |
|
kOTModemDevice = 13, /* Modem Pseudo-Device */ |
|
kOTFastEthernetDevice = 14, /* 100 MB Ethernet */ |
|
kOTFDDIDevice = 15, /* FDDI */ |
|
kOTIrDADevice = 16, /* IrDA Infrared */ |
|
kOTATMSNAPDevice = 17, /* ATM SNAP emulation */ |
|
kOTFibreChannelDevice = 18, /* Fibre Channel */ |
|
kOTFireWireDevice = 19, /* FireWire link Device */ |
|
kOTPseudoDevice = 1023, /* used where no other defined device type will work*/ |
|
kOTLastDeviceIndex = 1022 |
|
}; |
|
|
|
/* Special case values for the slot number element of an OTPortRef.*/ |
|
|
|
enum { |
|
kOTLastSlotNumber = 255, |
|
kOTLastOtherNumber = 255 |
|
}; |
|
|
|
typedef UInt16 OTSlotNumber; |
|
/* Accessor functions for the various elements of the OTPortRef.*/ |
|
/* |
|
* OTCreatePortRef() |
|
* |
|
* 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( OTPortRef ) |
|
OTCreatePortRef( |
|
OTBusType busType, |
|
OTDeviceType devType, |
|
OTSlotNumber slot, |
|
UInt16 other); |
|
|
|
|
|
/* |
|
* OTGetDeviceTypeFromPortRef() |
|
* |
|
* 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( OTDeviceType ) |
|
OTGetDeviceTypeFromPortRef(OTPortRef ref); |
|
|
|
|
|
/* |
|
* OTGetBusTypeFromPortRef() |
|
* |
|
* 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( UInt16 ) |
|
OTGetBusTypeFromPortRef(OTPortRef ref); |
|
|
|
|
|
/* |
|
* OTGetSlotFromPortRef() |
|
* |
|
* 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( OTSlotNumber ) |
|
OTGetSlotFromPortRef( |
|
OTPortRef ref, |
|
UInt16 * other); |
|
|
|
|
|
/* |
|
* OTSetDeviceTypeInPortRef() |
|
* |
|
* 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( OTPortRef ) |
|
OTSetDeviceTypeInPortRef( |
|
OTPortRef ref, |
|
OTDeviceType devType); |
|
|
|
|
|
/* |
|
* OTSetBusTypeInPortRef() |
|
* |
|
* 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( OTPortRef ) |
|
OTSetBusTypeInPortRef( |
|
OTPortRef ref, |
|
OTBusType busType); |
|
|
|
|
|
|
|
/* |
|
Convenience macros for generating specific types of OTPortRefs. |
|
*/ |
|
|
|
#define OTCreateNuBusPortRef(devType, slot, other) \ |
|
OTCreatePortRef(kOTNuBus, devType, slot, other) |
|
|
|
#define OTCreatePCIPortRef(devType, slot, other) \ |
|
OTCreatePortRef(kOTPCIBus, devType, slot, other) |
|
|
|
#define OTCreatePCCardPortRef(devType, slot, other) \ |
|
OTCreatePortRef(kOTPCCardBus, devType, slot, other) |
|
|
|
/* Name length definitions for various fields in OTPortRecord.*/ |
|
|
|
enum { |
|
kMaxModuleNameLength = 31, /* max length of a STREAMS module name*/ |
|
kMaxModuleNameSize = kMaxModuleNameLength + 1, |
|
kMaxProviderNameLength = kMaxModuleNameLength + 4, /* providers allow 4 characters for minor number*/ |
|
kMaxProviderNameSize = kMaxProviderNameLength + 1, |
|
kMaxSlotIDLength = 7, /* PCI slot names tend to be short*/ |
|
kMaxSlotIDSize = kMaxSlotIDLength + 1, |
|
kMaxResourceInfoLength = 31, /* max length of a configuration helper name*/ |
|
kMaxResourceInfoSize = 32, |
|
kMaxPortNameLength = kMaxModuleNameLength + 4, /* max size allowed to define a port*/ |
|
kMaxPortNameSize = kMaxPortNameLength + 1 |
|
}; |
|
|
|
/* |
|
Masks for the fPortFlags field of OTPortRecord |
|
If no bits are set, the port is currently inactive. |
|
*/ |
|
|
|
enum { |
|
kOTPortIsActive = 0x00000001, |
|
kOTPortIsDisabled = 0x00000002, |
|
kOTPortIsUnavailable = 0x00000004, |
|
kOTPortIsOffline = 0x00000008 |
|
}; |
|
|
|
/* Masks for the fInfoFlags field of the OTPortRecord.*/ |
|
|
|
enum { |
|
kOTPortIsDLPI = 0x00000001, |
|
kOTPortIsTPI = 0x00000002, |
|
kOTPortCanYield = 0x00000004, /* will not be set until the port is used for the first time*/ |
|
kOTPortCanArbitrate = 0x00000008, /* will not be set until the port is used for the first time*/ |
|
kOTPortIsTransitory = 0x00000010, |
|
kOTPortAutoConnects = 0x00000020, |
|
kOTPortIsSystemRegistered = 0x00004000, |
|
kOTPortIsPrivate = 0x00008000, |
|
kOTPortIsAlias = (unsigned long)0x80000000 |
|
}; |
|
|
|
/* |
|
One OTPortRecord is created for each instance of a port. |
|
For Instance 'enet' identifies an ethernet port. |
|
A OTPortRecord for each ethernet card it finds, with an |
|
OTPortRef that will uniquely allow the driver to determine which |
|
port it is supposed to open on. |
|
*/ |
|
|
|
struct OTPortRecord { |
|
OTPortRef fRef; |
|
UInt32 fPortFlags; |
|
UInt32 fInfoFlags; |
|
UInt32 fCapabilities; |
|
ItemCount fNumChildPorts; |
|
OTPortRef * fChildPorts; |
|
char fPortName[36]; |
|
char fModuleName[32]; |
|
char fSlotID[8]; |
|
char fResourceInfo[32]; |
|
char fReserved[164]; |
|
}; |
|
typedef struct OTPortRecord OTPortRecord; |
|
/* |
|
Routines for finding, registering and unregistering ports. |
|
IMPORTANT: |
|
These routines have two versions, one for the client and one |
|
for the kernel. Make sure you use and link with the right ones. |
|
*/ |
|
#if !OTKERNEL |
|
/* |
|
* OTGetIndexedPort() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientUtilLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( Boolean ) |
|
OTGetIndexedPort( |
|
OTPortRecord * portRecord, |
|
OTItemCount index); |
|
|
|
|
|
/* Index through the ports in the system*/ |
|
/* |
|
* OTFindPort() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientUtilLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( Boolean ) |
|
OTFindPort( |
|
OTPortRecord * portRecord, |
|
const char * portName); |
|
|
|
|
|
/* Find an OTPortRecord for a port using it's name*/ |
|
/* |
|
* OTFindPortByRef() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientUtilLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( Boolean ) |
|
OTFindPortByRef( |
|
OTPortRecord * portRecord, |
|
OTPortRef ref); |
|
|
|
|
|
/* Find an OTPortRecord for a port using it's OTPortRef*/ |
|
#if CALL_NOT_IN_CARBON |
|
/* |
|
* OTRegisterPort() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientUtilLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API_C( OSStatus ) |
|
OTRegisterPort( |
|
OTPortRecord * portRecord, |
|
void * ref); |
|
|
|
|
|
/* |
|
Register a port. The name the port was registered under is returned in |
|
the fPortName field. |
|
*/ |
|
/* |
|
* OTUnregisterPort() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientUtilLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API_C( OSStatus ) |
|
OTUnregisterPort( |
|
const char * portName, |
|
void ** ref); |
|
|
|
|
|
/* |
|
Unregister the port with the given name (If you re-register the |
|
port, it may get a different name - use OTChangePortState if |
|
that is not desireable). Since a single OTPortRef can be registered |
|
with several names, the API needs to use the portName rather than |
|
the OTPortRef to disambiguate. |
|
*/ |
|
/* |
|
* OTChangePortState() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientUtilLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API_C( OSStatus ) |
|
OTChangePortState( |
|
OTPortRef portRef, |
|
OTEventCode theChange, |
|
OTResult why); |
|
|
|
|
|
/* Change the state of the port.*/ |
|
#endif /* CALL_NOT_IN_CARBON */ |
|
|
|
#endif /* !OTKERNEL */ |
|
|
|
/* ***** Data Buffers ******/ |
|
/* |
|
TNetbuf is the basic structure used to pass data back and forth |
|
between the Open Transport protocols and their clients |
|
*/ |
|
|
|
struct TNetbuf { |
|
ByteCount maxlen; |
|
ByteCount len; |
|
UInt8 * buf; |
|
}; |
|
typedef struct TNetbuf TNetbuf; |
|
/* |
|
Some rarely used low-level routines in this file take a strbuf |
|
as a parameter. This is the raw streams equivalent of a TNetbuf. |
|
The key difference is that the maxlen and len fields are signed, |
|
which allows you to specify extra operations by providing a |
|
negative value. |
|
*/ |
|
|
|
|
|
struct strbuf { |
|
SInt32 maxlen; /* max buffer length */ |
|
SInt32 len; /* length of data */ |
|
char * buf; /* pointer to buffer */ |
|
}; |
|
typedef struct strbuf strbuf; |
|
/* |
|
OTData is used in a TNetbuf or netbuf to send |
|
non-contiguous data. Set the 'len' field of the netbuf to the |
|
constant kNetbufDataIsOTData to signal that the 'buf' field of the |
|
netbuf actually points to one of these structures instead of a |
|
memory buffer. |
|
*/ |
|
struct OTData { |
|
void * fNext; |
|
void * fData; |
|
ByteCount fLen; |
|
}; |
|
typedef struct OTData OTData; |
|
enum { |
|
kNetbufDataIsOTData = (unsigned long)0xFFFFFFFE |
|
}; |
|
|
|
|
|
/* |
|
OTBuffer is used for no-copy receives. When receiving, you can |
|
set the receive length to kOTNetbufDataIsOTBufferStar and then |
|
pass the address of an OTBuffer* as the receive buffer. OT will |
|
fill it out to point to a chain of OTBuffers. |
|
When you are done with it, you must call the OTReleaseBuffer function. |
|
For best performance, you need to call OTReleaseBuffer quickly. |
|
Only data netbufs may use this - no netbufs for addresses or options, or the like. |
|
Any OTBuffer returned to you by OT is read only! |
|
The astute will notice that this has a high correlation with the |
|
STREAMS msgb data type. The fields are commented with their |
|
corresponding msgb field name. |
|
*/ |
|
|
|
struct OTBuffer { |
|
void * fLink; /* b_next*/ |
|
void * fLink2; /* b_prev*/ |
|
struct OTBuffer * fNext; /* b_cont*/ |
|
UInt8 * fData; /* b_rptr*/ |
|
ByteCount fLen; /* b_wptr*/ |
|
void * fSave; /* b_datap*/ |
|
UInt8 fBand; /* b_band*/ |
|
UInt8 fType; /* b_pad1*/ |
|
UInt8 fPad1; |
|
UInt8 fFlags; /* b_flag*/ |
|
}; |
|
typedef struct OTBuffer OTBuffer; |
|
enum { |
|
kOTNetbufDataIsOTBufferStar = (unsigned long)0xFFFFFFFD |
|
}; |
|
|
|
/* |
|
OTBufferInfo is used with OTReadBuffer to keep track of where you |
|
are in the buffer, since the OTBuffer is "read-only". |
|
*/ |
|
/* Use the OTInitBuffer macro to initialise this structure from an OTBuffer chain.*/ |
|
struct OTBufferInfo { |
|
OTBuffer * fBuffer; |
|
ByteCount fOffset; |
|
UInt8 fPad; |
|
}; |
|
typedef struct OTBufferInfo OTBufferInfo; |
|
|
|
#define OTInitBufferInfo(infoPtr, theBuffer) \ |
|
(infoPtr)->fBuffer = theBuffer; \ |
|
(infoPtr)->fPad = (theBuffer)->fPad1; \ |
|
(infoPtr)->fOffset = 0 |
|
|
|
/* |
|
If the endpoint supports "raw mode" (the T_CAN_SUPPORT_MDATA bit will |
|
be set in the TEndpointInfo::flags field), then you specify the |
|
raw mode packet by putting the kOTNetbufIsRawMode value in |
|
the udata.addr.len field when calling OTSndUData and also set the |
|
udata.opt.len, udata.opt.buf, and udata.addr.buf fields to 0. |
|
*/ |
|
|
|
enum { |
|
kOTNetbufIsRawMode = (unsigned long)0xFFFFFFFF |
|
}; |
|
|
|
/* |
|
***** Standard XTI Parameter Types ***** |
|
These structures are all used as parameters to the standard |
|
XTI routines. |
|
*/ |
|
|
|
/* |
|
TBind holds binding information for calls to |
|
OTGetProtAddress, OTResolveAddress and OTBind. |
|
*/ |
|
|
|
struct TBind { |
|
TNetbuf addr; |
|
OTQLen qlen; |
|
}; |
|
typedef struct TBind TBind; |
|
/* |
|
TDiscon is passed to RcvDisconnect to find out additional information |
|
about the disconnect. |
|
*/ |
|
struct TDiscon { |
|
TNetbuf udata; |
|
OTReason reason; |
|
OTSequence sequence; |
|
}; |
|
typedef struct TDiscon TDiscon; |
|
/* |
|
TCall holds information about a connection and is a parameter to |
|
OTConnect, OTRcvConnect, OTListen, OTAccept, and OTSndDisconnect. |
|
*/ |
|
struct TCall { |
|
TNetbuf addr; |
|
TNetbuf opt; |
|
TNetbuf udata; |
|
OTSequence sequence; |
|
}; |
|
typedef struct TCall TCall; |
|
/* TUnitData describes a datagram in calls to OTSndUData and OTRcvUData.*/ |
|
struct TUnitData { |
|
TNetbuf addr; |
|
TNetbuf opt; |
|
TNetbuf udata; |
|
}; |
|
typedef struct TUnitData TUnitData; |
|
/* |
|
TUDErr is used to get information about a datagram error using |
|
OTRcvUDErr. |
|
*/ |
|
struct TUDErr { |
|
TNetbuf addr; |
|
TNetbuf opt; |
|
SInt32 error; |
|
}; |
|
typedef struct TUDErr TUDErr; |
|
/* TOptMgmt is passed to the OTOptionManagement call to read or set protocol*/ |
|
struct TOptMgmt { |
|
TNetbuf opt; |
|
OTFlags flags; |
|
}; |
|
typedef struct TOptMgmt TOptMgmt; |
|
/* |
|
***** Transactional XTI Parameter Types ***** |
|
These structures are all used as parameters to the OT's |
|
XTI-like routines for transaction protocols. |
|
*/ |
|
/* |
|
TRequest is passed to OTSndRequest and OTRcvRequest that contains the information |
|
about the request. |
|
*/ |
|
|
|
struct TRequest { |
|
TNetbuf data; |
|
TNetbuf opt; |
|
OTSequence sequence; |
|
}; |
|
typedef struct TRequest TRequest; |
|
/* TReply is passed to OTSndReply to send a reply to an incoming request.*/ |
|
struct TReply { |
|
TNetbuf data; |
|
TNetbuf opt; |
|
OTSequence sequence; |
|
}; |
|
typedef struct TReply TReply; |
|
/* |
|
TUnitRequest is passed to OTSndURequest and OTRcvURequest that contains |
|
the information about the request. |
|
*/ |
|
struct TUnitRequest { |
|
TNetbuf addr; |
|
TNetbuf opt; |
|
TNetbuf udata; |
|
OTSequence sequence; |
|
}; |
|
typedef struct TUnitRequest TUnitRequest; |
|
/* TUnitReply is passed to OTSndUReply to send a reply to an incoming request.*/ |
|
struct TUnitReply { |
|
TNetbuf opt; |
|
TNetbuf udata; |
|
OTSequence sequence; |
|
}; |
|
typedef struct TUnitReply TUnitReply; |
|
/* |
|
***** Mapper Parameter Types ***** |
|
These structures are all used as parameters to the OT's |
|
mapper routines. |
|
*/ |
|
/* TRegisterRequest holds the name to register in a call to OTRegisterName.*/ |
|
|
|
struct TRegisterRequest { |
|
TNetbuf name; |
|
TNetbuf addr; |
|
OTFlags flags; |
|
}; |
|
typedef struct TRegisterRequest TRegisterRequest; |
|
/* |
|
TRegisterReply returns information about the registered name in a call |
|
to OTRegisterName. |
|
*/ |
|
struct TRegisterReply { |
|
TNetbuf addr; |
|
OTNameID nameid; |
|
}; |
|
typedef struct TRegisterReply TRegisterReply; |
|
/* TLookupRequest holds the name to look up in a call to OTLookupName.*/ |
|
struct TLookupRequest { |
|
TNetbuf name; |
|
TNetbuf addr; |
|
UInt32 maxcnt; |
|
OTTimeout timeout; |
|
OTFlags flags; |
|
}; |
|
typedef struct TLookupRequest TLookupRequest; |
|
/* |
|
TLookupReply returns information about the found names after a call |
|
to OTLookupName. |
|
*/ |
|
struct TLookupReply { |
|
TNetbuf names; |
|
UInt32 rspcount; |
|
}; |
|
typedef struct TLookupReply TLookupReply; |
|
/* |
|
TLookupBuffer describes the contents of the names buffer pointed |
|
to by the TLookupReply. |
|
*/ |
|
struct TLookupBuffer { |
|
UInt16 fAddressLength; |
|
UInt16 fNameLength; |
|
UInt8 fAddressBuffer[1]; |
|
}; |
|
typedef struct TLookupBuffer TLookupBuffer; |
|
|
|
/* |
|
OTNextLookupBuffer allows you to step through a packed array |
|
of TLookupBuffers. |
|
*/ |
|
|
|
#define OTNextLookupBuffer(buf) \ |
|
((TLookupBuffer*) \ |
|
((char*)buf + ((OTOffsetOf(TLookupBuffer, fAddressBuffer) + buf->fAddressLength + buf->fNameLength + 3) & ~3))) |
|
|
|
/* ***** Initializing and Shutting Down Open Transport ******/ |
|
|
|
#if !OTKERNEL |
|
typedef struct OpaqueOTClientContextPtr* OTClientContextPtr; |
|
/* |
|
For Carbon the InitOpenTransport interface has changed so it takes a flags parameter |
|
and returns a client context pointer. |
|
The flag passed to indicates whether OT should be initialized for application use or for some other target |
|
(for example, plugins that run in an application context but not the application itself.) |
|
Applications that are not interested in the value of the client context pointer may pass NULL |
|
as outClientContext -- they will pass NULL to other routines that take a OTClientContextPtr. |
|
*/ |
|
typedef UInt32 OTInitializationFlags; |
|
enum { |
|
kInitOTForApplicationMask = 1, |
|
kInitOTForExtensionMask = 2 |
|
}; |
|
|
|
/* |
|
* InitOpenTransportInContext() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
InitOpenTransportInContext( |
|
OTInitializationFlags flags, |
|
OTClientContextPtr * outClientContext); /* can be NULL */ |
|
|
|
|
|
|
|
/* |
|
Under Carbon, CloseOpenTransport takes a client context pointer. Applications may pass NULL |
|
after calling InitOpenTransport(kInitOTForApplicationMask, ...). Non-applications must always pass a |
|
valid client context. |
|
*/ |
|
/* |
|
* CloseOpenTransportInContext() |
|
* |
|
* 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 ) |
|
CloseOpenTransportInContext(OTClientContextPtr clientContext); |
|
|
|
|
|
|
|
#if CALL_NOT_IN_CARBON |
|
/* |
|
* InitOpenTransport() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
InitOpenTransport(void); |
|
|
|
|
|
/* |
|
* InitOpenTransportUtilities() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
InitOpenTransportUtilities(void); |
|
|
|
|
|
/* |
|
* CloseOpenTransport() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( void ) |
|
CloseOpenTransport(void); |
|
|
|
|
|
/* |
|
* OTRegisterAsClient() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTRegisterAsClient( |
|
OTClientName name, |
|
OTNotifyUPP proc); |
|
|
|
|
|
/* |
|
This registers yourself as a client for any miscellaneous Open Transport |
|
notifications that come along. CloseOpenTransport will automatically do |
|
an OTUnregisterAsClient, if you have not already done so. |
|
*/ |
|
/* |
|
* OTUnregisterAsClient() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTUnregisterAsClient(void); |
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */ |
|
|
|
/* |
|
* OTRegisterAsClientInContext() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: in CarbonLib 1.3 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTRegisterAsClientInContext( |
|
OTClientName name, |
|
OTNotifyUPP proc, |
|
OTClientContextPtr clientContext); /* can be NULL */ |
|
|
|
|
|
/* |
|
* OTUnregisterAsClientInContext() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: in CarbonLib 1.3 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTUnregisterAsClientInContext(OTClientContextPtr clientContext); |
|
|
|
|
|
#if OTCARBONAPPLICATION |
|
/* The following macro may be used by applications only.*/ |
|
#define InitOpenTransport() InitOpenTransportInContext(kInitOTForApplicationMask, NULL) |
|
#define CloseOpenTransport() CloseOpenTransportInContext(NULL) |
|
#define OTRegisterAsClient(name, proc) OTRegisterAsClientInContext(name, proc, NULL) |
|
#define OTUnregisterAsClient() OTUnregisterAsClientInContext(NULL) |
|
#endif /* OTCARBONAPPLICATION */ |
|
|
|
#endif /* !OTKERNEL */ |
|
|
|
/* ***** Tasking Model ******/ |
|
/* |
|
OTEnterInterrupt/OTLeaveInterrupt are normally used within the kernel to |
|
tell Open Transport we're at hardware interrupt time. Clients can also |
|
them to do the same. |
|
*/ |
|
|
|
#if CALL_NOT_IN_CARBON |
|
/* |
|
* OTEnterInterrupt() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( void ) |
|
OTEnterInterrupt(void); |
|
|
|
|
|
/* |
|
* OTLeaveInterrupt() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( void ) |
|
OTLeaveInterrupt(void); |
|
|
|
|
|
/* |
|
* OTIsAtInterruptLevel() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API_C( Boolean ) |
|
OTIsAtInterruptLevel(void); |
|
|
|
|
|
/* |
|
* OTCanLoadLibraries() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API_C( Boolean ) |
|
OTCanLoadLibraries(void); |
|
|
|
|
|
/* |
|
All OT task callbacks use the same prototype, shown below. |
|
This is only a UPP for CFM-68K clients. |
|
*/ |
|
|
|
#endif /* CALL_NOT_IN_CARBON */ |
|
|
|
typedef CALLBACK_API( void , OTProcessProcPtr )(void * arg); |
|
typedef TVECTOR_UPP_TYPE(OTProcessProcPtr) OTProcessUPP; |
|
/* |
|
* NewOTProcessUPP() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: available as macro/inline |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API_C( OTProcessUPP ) |
|
NewOTProcessUPP(OTProcessProcPtr userRoutine); |
|
#if !OPAQUE_UPP_TYPES |
|
enum { uppOTProcessProcInfo = 0x000000C0 }; /* pascal no_return_value Func(4_bytes) */ |
|
#ifdef __cplusplus |
|
inline DEFINE_API_C(OTProcessUPP) NewOTProcessUPP(OTProcessProcPtr userRoutine) { return userRoutine; } |
|
#else |
|
#define NewOTProcessUPP(userRoutine) (userRoutine) |
|
#endif |
|
#endif |
|
|
|
/* |
|
* DisposeOTProcessUPP() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: available as macro/inline |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API_C( void ) |
|
DisposeOTProcessUPP(OTProcessUPP userUPP); |
|
#if !OPAQUE_UPP_TYPES |
|
#ifdef __cplusplus |
|
inline DEFINE_API_C(void) DisposeOTProcessUPP(OTProcessUPP) {} |
|
#else |
|
#define DisposeOTProcessUPP(userUPP) |
|
#endif |
|
#endif |
|
|
|
/* |
|
* InvokeOTProcessUPP() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: available as macro/inline |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API_C( void ) |
|
InvokeOTProcessUPP( |
|
void * arg, |
|
OTProcessUPP userUPP); |
|
#if !OPAQUE_UPP_TYPES |
|
#ifdef __cplusplus |
|
inline DEFINE_API_C(void) InvokeOTProcessUPP(void * arg, OTProcessUPP userUPP) { (*userUPP)(arg); } |
|
#else |
|
#define InvokeOTProcessUPP(arg, userUPP) (*userUPP)(arg) |
|
#endif |
|
#endif |
|
|
|
#if !OTKERNEL |
|
/* |
|
Under Carbon, OTCreateDeferredTask takes a client context pointer. Applications may pass NULL |
|
after calling InitOpenTransport(kInitOTForApplicationMask, ...). Non-applications must always pass a |
|
valid client context. |
|
*/ |
|
/* |
|
* OTCreateDeferredTaskInContext() |
|
* |
|
* 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 ) |
|
OTCreateDeferredTaskInContext( |
|
OTProcessUPP upp, |
|
void * arg, |
|
OTClientContextPtr clientContext); /* can be NULL */ |
|
|
|
|
|
#endif /* !OTKERNEL */ |
|
|
|
/* |
|
OT deferred tasks are often more convenience that standard Mac OS |
|
although they have no significant advantages beyond convenience. |
|
*/ |
|
|
|
|
|
typedef long OTDeferredTaskRef; |
|
#if CALL_NOT_IN_CARBON |
|
/* |
|
* OTCreateDeferredTask() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OTDeferredTaskRef ) |
|
OTCreateDeferredTask( |
|
OTProcessUPP proc, |
|
void * arg); |
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */ |
|
|
|
/* |
|
* OTScheduleDeferredTask() |
|
* |
|
* 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( Boolean ) |
|
OTScheduleDeferredTask(OTDeferredTaskRef dtCookie); |
|
|
|
|
|
#if CALL_NOT_IN_CARBON |
|
/* |
|
* OTScheduleInterruptTask() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( Boolean ) |
|
OTScheduleInterruptTask(OTDeferredTaskRef dtCookie); |
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */ |
|
|
|
/* |
|
* OTDestroyDeferredTask() |
|
* |
|
* 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( OSStatus ) |
|
OTDestroyDeferredTask(OTDeferredTaskRef dtCookie); |
|
|
|
|
|
#if OTCARBONAPPLICATION |
|
/* The following macro may be used by applications only.*/ |
|
#define OTCreateDeferredTask(upp, arg) OTCreateDeferredTaskInContext(upp, arg, NULL) |
|
#endif /* OTCARBONAPPLICATION */ |
|
|
|
#if !OTKERNEL |
|
/* |
|
OT system tasks allow you to schedule a procedure to be called |
|
at system task time. Potentially useful, but it relies on someone |
|
calling SystemTask (or WaitNextEvent, which calls SystemTask). |
|
Not available to kernel code because relying on system task time |
|
to make progress is likely to result in deadlocks. |
|
*/ |
|
typedef long OTSystemTaskRef; |
|
#if CALL_NOT_IN_CARBON |
|
/* |
|
* OTCreateSystemTask() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OTSystemTaskRef ) |
|
OTCreateSystemTask( |
|
OTProcessUPP proc, |
|
void * arg); |
|
|
|
|
|
/* |
|
* OTDestroySystemTask() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTDestroySystemTask(OTSystemTaskRef stCookie); |
|
|
|
|
|
/* |
|
* OTScheduleSystemTask() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( Boolean ) |
|
OTScheduleSystemTask(OTSystemTaskRef stCookie); |
|
|
|
|
|
/* |
|
* OTCancelSystemTask() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTUtilityLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( Boolean ) |
|
OTCancelSystemTask(OTSystemTaskRef stCookie); |
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */ |
|
|
|
/* |
|
* OTCanMakeSyncCall() |
|
* |
|
* 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( Boolean ) |
|
OTCanMakeSyncCall(void); |
|
|
|
|
|
#endif /* !OTKERNEL */ |
|
|
|
/* ***** Interface to Providers ******/ |
|
#if !OTKERNEL |
|
#if CALL_NOT_IN_CARBON |
|
/* |
|
* OTAsyncOpenProvider() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTAsyncOpenProvider( |
|
OTConfigurationRef cfig, |
|
OTOpenFlags flags, |
|
OTNotifyUPP proc, |
|
void * contextPtr); |
|
|
|
|
|
/* |
|
* OTOpenProvider() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( ProviderRef ) |
|
OTOpenProvider( |
|
OTConfigurationRef cfig, |
|
OTOpenFlags flags, |
|
OSStatus * errPtr); |
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */ |
|
|
|
/* |
|
* OTCloseProvider() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTCloseProvider(ProviderRef ref); |
|
|
|
|
|
#if CALL_NOT_IN_CARBON |
|
/* |
|
* OTTransferProviderOwnership() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( ProviderRef ) |
|
OTTransferProviderOwnership( |
|
ProviderRef ref, |
|
OTClient prevOwner, |
|
OSStatus * errPtr); |
|
|
|
|
|
/* |
|
* OTWhoAmI() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OTClient ) |
|
OTWhoAmI(void); |
|
|
|
|
|
/* |
|
* OTGetProviderPortRef() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OTPortRef ) |
|
OTGetProviderPortRef(ProviderRef ref); |
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */ |
|
|
|
/* |
|
* OTIoctl() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( SInt32 ) |
|
OTIoctl( |
|
ProviderRef ref, |
|
UInt32 cmd, |
|
void * data); |
|
|
|
|
|
#if CALL_NOT_IN_CARBON |
|
/* |
|
* OTGetMessage() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OTResult ) |
|
OTGetMessage( |
|
ProviderRef ref, |
|
strbuf * ctlbuf, |
|
strbuf * databuf, |
|
OTFlags * flagsPtr); |
|
|
|
|
|
/* |
|
* OTGetPriorityMessage() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OTResult ) |
|
OTGetPriorityMessage( |
|
ProviderRef ref, |
|
strbuf * ctlbuf, |
|
strbuf * databuf, |
|
OTBand * bandPtr, |
|
OTFlags * flagsPtr); |
|
|
|
|
|
/* |
|
* OTPutMessage() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTPutMessage( |
|
ProviderRef ref, |
|
const strbuf * ctlbuf, |
|
const strbuf * databuf, |
|
OTFlags flags); |
|
|
|
|
|
/* |
|
* OTPutPriorityMessage() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTPutPriorityMessage( |
|
ProviderRef ref, |
|
const strbuf * ctlbuf, |
|
const strbuf * databuf, |
|
OTBand band, |
|
OTFlags flags); |
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */ |
|
|
|
/* |
|
* OTSetAsynchronous() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTSetAsynchronous(ProviderRef ref); |
|
|
|
|
|
/* |
|
* OTSetSynchronous() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTSetSynchronous(ProviderRef ref); |
|
|
|
|
|
/* |
|
* OTIsSynchronous() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( Boolean ) |
|
OTIsSynchronous(ProviderRef ref); |
|
|
|
|
|
/* |
|
* OTSetBlocking() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTSetBlocking(ProviderRef ref); |
|
|
|
|
|
/* |
|
* OTSetNonBlocking() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTSetNonBlocking(ProviderRef ref); |
|
|
|
|
|
/* |
|
* OTIsBlocking() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( Boolean ) |
|
OTIsBlocking(ProviderRef ref); |
|
|
|
|
|
/* |
|
* OTInstallNotifier() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTInstallNotifier( |
|
ProviderRef ref, |
|
OTNotifyUPP proc, |
|
void * contextPtr); |
|
|
|
|
|
/* |
|
* OTUseSyncIdleEvents() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTUseSyncIdleEvents( |
|
ProviderRef ref, |
|
Boolean useEvents); |
|
|
|
|
|
/* |
|
* OTRemoveNotifier() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( void ) |
|
OTRemoveNotifier(ProviderRef ref); |
|
|
|
|
|
/* |
|
* OTLeaveNotifier() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( void ) |
|
OTLeaveNotifier(ProviderRef ref); |
|
|
|
|
|
/* |
|
* OTEnterNotifier() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( Boolean ) |
|
OTEnterNotifier(ProviderRef ref); |
|
|
|
|
|
/* |
|
* OTAckSends() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTAckSends(ProviderRef ref); |
|
|
|
|
|
/* |
|
* OTDontAckSends() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTDontAckSends(ProviderRef ref); |
|
|
|
|
|
/* |
|
* OTIsAckingSends() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( Boolean ) |
|
OTIsAckingSends(ProviderRef ref); |
|
|
|
|
|
/* |
|
* OTCancelSynchronousCalls() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTCancelSynchronousCalls( |
|
ProviderRef ref, |
|
OSStatus err); |
|
|
|
|
|
|
|
#define OTIsNonBlocking(ref) (!OTIsBlocking(ref)) |
|
#define OTIsAsynchronous(ref) (!OTIsSynchronous(ref)) |
|
|
|
#endif /* !OTKERNEL */ |
|
|
|
/* ***** Interface to Endpoints ******/ |
|
#if !OTKERNEL |
|
/* Open/Close*/ |
|
/* |
|
Under Carbon, the OpenEndpoint routines take a client context pointer. Applications may pass NULL after |
|
calling InitOpenTransport(kInitOTForApplicationMask, ...). Non-applications must always pass a |
|
valid client context. |
|
*/ |
|
/* |
|
* OTOpenEndpointInContext() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( EndpointRef ) |
|
OTOpenEndpointInContext( |
|
OTConfigurationRef config, |
|
OTOpenFlags oflag, |
|
TEndpointInfo * info, /* can be NULL */ |
|
OSStatus * err, |
|
OTClientContextPtr clientContext); /* can be NULL */ |
|
|
|
|
|
/* |
|
* OTAsyncOpenEndpointInContext() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTAsyncOpenEndpointInContext( |
|
OTConfigurationRef config, |
|
OTOpenFlags oflag, |
|
TEndpointInfo * info, /* can be NULL */ |
|
OTNotifyUPP upp, |
|
void * contextPtr, |
|
OTClientContextPtr clientContext); /* can be NULL */ |
|
|
|
|
|
|
|
|
|
#if CALL_NOT_IN_CARBON |
|
/* |
|
* OTOpenEndpoint() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( EndpointRef ) |
|
OTOpenEndpoint( |
|
OTConfigurationRef cfig, |
|
OTOpenFlags oflag, |
|
TEndpointInfo * info, /* can be NULL */ |
|
OSStatus * err); |
|
|
|
|
|
/* |
|
* OTAsyncOpenEndpoint() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTAsyncOpenEndpoint( |
|
OTConfigurationRef cfig, |
|
OTOpenFlags oflag, |
|
TEndpointInfo * info, /* can be NULL */ |
|
OTNotifyUPP proc, |
|
void * contextPtr); |
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */ |
|
|
|
#if OTCARBONAPPLICATION |
|
/* The following macros may be used by applications only.*/ |
|
#define OTOpenEndpoint(config, oflag, info, err) OTOpenEndpointInContext(config, oflag, info, err, NULL) |
|
#define OTAsyncOpenEndpoint(config, oflag, info, proc, contextPtr) OTAsyncOpenEndpointInContext(config, oflag, info, proc, contextPtr, NULL) |
|
#endif /* OTCARBONAPPLICATION */ |
|
|
|
/* Misc Information*/ |
|
|
|
/* |
|
* OTGetEndpointInfo() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTGetEndpointInfo( |
|
EndpointRef ref, |
|
TEndpointInfo * info); |
|
|
|
|
|
/* |
|
* OTGetEndpointState() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OTResult ) |
|
OTGetEndpointState(EndpointRef ref); |
|
|
|
|
|
/* |
|
* OTLook() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OTResult ) |
|
OTLook(EndpointRef ref); |
|
|
|
|
|
#if CALL_NOT_IN_CARBON |
|
/* |
|
* OTSync() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OTResult ) |
|
OTSync(EndpointRef ref); |
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */ |
|
|
|
/* |
|
* OTCountDataBytes() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OTResult ) |
|
OTCountDataBytes( |
|
EndpointRef ref, |
|
OTByteCount * countPtr); |
|
|
|
|
|
/* |
|
* OTGetProtAddress() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTGetProtAddress( |
|
EndpointRef ref, |
|
TBind * boundAddr, /* can be NULL */ |
|
TBind * peerAddr); /* can be NULL */ |
|
|
|
|
|
/* |
|
* OTResolveAddress() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTResolveAddress( |
|
EndpointRef ref, |
|
TBind * reqAddr, |
|
TBind * retAddr, |
|
OTTimeout timeOut); |
|
|
|
|
|
/* Allocating structures*/ |
|
|
|
/* |
|
Note: |
|
In general, Apple recommends that you avoid the OTAlloc call because |
|
using it extensively causes your program to allocate and deallocate |
|
many memory blocks, with each extra memory allocation costing time. |
|
*/ |
|
|
|
/* |
|
Under Carbon, OTAlloc takes a client context pointer. Applications may pass NULL after |
|
calling InitOpenTransport(kInitOTForApplicationMask, ...). Non-applications must always pass a |
|
valid client context. |
|
*/ |
|
/* |
|
* OTAllocInContext() |
|
* |
|
* 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 * ) |
|
OTAllocInContext( |
|
EndpointRef ref, |
|
OTStructType structType, |
|
UInt32 fields, |
|
OSStatus * err, |
|
OTClientContextPtr clientContext); /* can be NULL */ |
|
|
|
|
|
#if CALL_NOT_IN_CARBON |
|
/* |
|
* OTAlloc() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( void * ) |
|
OTAlloc( |
|
EndpointRef ref, |
|
OTStructType structType, |
|
OTFieldsType fields, |
|
OSStatus * err); |
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */ |
|
|
|
#if OTCARBONAPPLICATION |
|
/* The following macro may be used by applications only.*/ |
|
#define OTAlloc(ref, structType, fields, err) OTAllocInContext(ref, structType, fields, err, NULL) |
|
#endif /* OTCARBONAPPLICATION */ |
|
|
|
/* |
|
* OTFree() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OTResult ) |
|
OTFree( |
|
void * ptr, |
|
OTStructType structType); |
|
|
|
|
|
/* Option management*/ |
|
|
|
/* It looks simple enough...*/ |
|
|
|
/* |
|
* OTOptionManagement() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTOptionManagement( |
|
EndpointRef ref, |
|
TOptMgmt * req, |
|
TOptMgmt * ret); |
|
|
|
|
|
/* ... but then the hidden complexity emerges.*/ |
|
|
|
#if CALL_NOT_IN_CARBON |
|
/* |
|
* OTCreateOptions() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientUtilLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTCreateOptions( |
|
const char * endPtName, |
|
char ** strPtr, |
|
TNetbuf * buf); |
|
|
|
|
|
/* |
|
* OTCreateOptionString() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientUtilLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTCreateOptionString( |
|
const char * endPtName, |
|
TOption ** opt, |
|
void * bufEnd, |
|
char * str, |
|
OTByteCount stringSize); |
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */ |
|
|
|
/* |
|
* OTNextOption() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTNextOption( |
|
UInt8 * buffer, |
|
UInt32 buflen, |
|
TOption ** prevOptPtr); |
|
|
|
|
|
/* |
|
* OTFindOption() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( TOption * ) |
|
OTFindOption( |
|
UInt8 * buffer, |
|
UInt32 buflen, |
|
OTXTILevel level, |
|
OTXTIName name); |
|
|
|
|
|
/* Bind/Unbind*/ |
|
|
|
/* |
|
* OTBind() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTBind( |
|
EndpointRef ref, |
|
TBind * reqAddr, /* can be NULL */ |
|
TBind * retAddr); /* can be NULL */ |
|
|
|
|
|
/* |
|
* OTUnbind() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTUnbind(EndpointRef ref); |
|
|
|
|
|
/* Connection creation/tear-down*/ |
|
|
|
/* |
|
* OTConnect() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTConnect( |
|
EndpointRef ref, |
|
TCall * sndCall, |
|
TCall * rcvCall); /* can be NULL */ |
|
|
|
|
|
/* |
|
* OTRcvConnect() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTRcvConnect( |
|
EndpointRef ref, |
|
TCall * call); /* can be NULL */ |
|
|
|
|
|
/* |
|
* OTListen() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTListen( |
|
EndpointRef ref, |
|
TCall * call); |
|
|
|
|
|
/* |
|
* OTAccept() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTAccept( |
|
EndpointRef listener, |
|
EndpointRef worker, |
|
TCall * call); |
|
|
|
|
|
/* |
|
* OTSndDisconnect() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTSndDisconnect( |
|
EndpointRef ref, |
|
TCall * call); /* can be NULL */ |
|
|
|
|
|
/* |
|
* OTSndOrderlyDisconnect() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTSndOrderlyDisconnect(EndpointRef ref); |
|
|
|
|
|
/* |
|
* OTRcvDisconnect() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTRcvDisconnect( |
|
EndpointRef ref, |
|
TDiscon * discon); /* can be NULL */ |
|
|
|
|
|
/* |
|
* OTRcvOrderlyDisconnect() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTRcvOrderlyDisconnect(EndpointRef ref); |
|
|
|
|
|
/* Connection-oriented send/receive*/ |
|
|
|
/* |
|
* OTRcv() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OTResult ) |
|
OTRcv( |
|
EndpointRef ref, |
|
void * buf, |
|
OTByteCount nbytes, |
|
OTFlags * flags); |
|
|
|
|
|
/* |
|
* OTSnd() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OTResult ) |
|
OTSnd( |
|
EndpointRef ref, |
|
void * buf, |
|
OTByteCount nbytes, |
|
OTFlags flags); |
|
|
|
|
|
/* Connectionless send/receive*/ |
|
|
|
/* |
|
* OTSndUData() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTSndUData( |
|
EndpointRef ref, |
|
TUnitData * udata); |
|
|
|
|
|
/* |
|
* OTRcvUData() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTRcvUData( |
|
EndpointRef ref, |
|
TUnitData * udata, |
|
OTFlags * flags); |
|
|
|
|
|
/* |
|
* OTRcvUDErr() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTRcvUDErr( |
|
EndpointRef ref, |
|
TUDErr * uderr); /* can be NULL */ |
|
|
|
|
|
/* Connection-oriented transactions*/ |
|
|
|
#if CALL_NOT_IN_CARBON |
|
/* |
|
* OTSndRequest() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTSndRequest( |
|
EndpointRef ref, |
|
TRequest * req, |
|
OTFlags reqFlags); |
|
|
|
|
|
/* |
|
* OTRcvReply() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTRcvReply( |
|
EndpointRef ref, |
|
TReply * reply, |
|
OTFlags * replyFlags); |
|
|
|
|
|
/* |
|
* OTSndReply() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTSndReply( |
|
EndpointRef ref, |
|
TReply * reply, |
|
OTFlags replyFlags); |
|
|
|
|
|
/* |
|
* OTRcvRequest() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTRcvRequest( |
|
EndpointRef ref, |
|
TRequest * req, |
|
OTFlags * reqFlags); |
|
|
|
|
|
/* |
|
* OTCancelRequest() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTCancelRequest( |
|
EndpointRef ref, |
|
OTSequence sequence); |
|
|
|
|
|
/* |
|
* OTCancelReply() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTCancelReply( |
|
EndpointRef ref, |
|
OTSequence sequence); |
|
|
|
|
|
/* Connectionless transactions*/ |
|
|
|
/* |
|
* OTSndURequest() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTSndURequest( |
|
EndpointRef ref, |
|
TUnitRequest * req, |
|
OTFlags reqFlags); |
|
|
|
|
|
/* |
|
* OTRcvUReply() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTRcvUReply( |
|
EndpointRef ref, |
|
TUnitReply * reply, |
|
OTFlags * replyFlags); |
|
|
|
|
|
/* |
|
* OTSndUReply() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTSndUReply( |
|
EndpointRef ref, |
|
TUnitReply * reply, |
|
OTFlags replyFlags); |
|
|
|
|
|
/* |
|
* OTRcvURequest() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTRcvURequest( |
|
EndpointRef ref, |
|
TUnitRequest * req, |
|
OTFlags * reqFlags); |
|
|
|
|
|
/* |
|
* OTCancelURequest() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTCancelURequest( |
|
EndpointRef ref, |
|
OTSequence seq); |
|
|
|
|
|
/* |
|
* OTCancelUReply() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTCancelUReply( |
|
EndpointRef ref, |
|
OTSequence seq); |
|
|
|
|
|
/* Interface to Mappers*/ |
|
|
|
|
|
/* |
|
Under Carbon, the OpenMapper routines take a client context pointer. Applications may pass NULL after |
|
calling InitOpenTransport(kInitOTForApplicationMask, ...). Non-applications must always pass a |
|
valid client context. |
|
*/ |
|
#endif /* CALL_NOT_IN_CARBON */ |
|
|
|
/* |
|
* OTAsyncOpenMapperInContext() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTAsyncOpenMapperInContext( |
|
OTConfigurationRef config, |
|
OTOpenFlags oflag, |
|
OTNotifyUPP upp, |
|
void * contextPtr, |
|
OTClientContextPtr clientContext); /* can be NULL */ |
|
|
|
|
|
/* |
|
* OTOpenMapperInContext() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( MapperRef ) |
|
OTOpenMapperInContext( |
|
OTConfigurationRef config, |
|
OTOpenFlags oflag, |
|
OSStatus * err, |
|
OTClientContextPtr clientContext); /* can be NULL */ |
|
|
|
|
|
|
|
#if CALL_NOT_IN_CARBON |
|
/* |
|
* OTAsyncOpenMapper() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTAsyncOpenMapper( |
|
OTConfigurationRef cfig, |
|
OTOpenFlags oflag, |
|
OTNotifyUPP proc, |
|
void * contextPtr); |
|
|
|
|
|
/* |
|
* OTOpenMapper() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API( MapperRef ) |
|
OTOpenMapper( |
|
OTConfigurationRef cfig, |
|
OTOpenFlags oflag, |
|
OSStatus * err); |
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */ |
|
|
|
#if OTCARBONAPPLICATION |
|
/* The following macros may be used by applications only.*/ |
|
#define OTAsyncOpenMapper(config, oflag, proc, contextPtr) OTAsyncOpenMapperInContext(config, oflag, proc, contextPtr, NULL) |
|
#define OTOpenMapper(config, oflag, err) OTOpenMapperInContext(config, oflag, err, NULL) |
|
#endif /* OTCARBONAPPLICATION */ |
|
|
|
/* |
|
* OTRegisterName() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTRegisterName( |
|
MapperRef ref, |
|
TRegisterRequest * req, |
|
TRegisterReply * reply); |
|
|
|
|
|
/* |
|
* OTDeleteName() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTDeleteName( |
|
MapperRef ref, |
|
TNetbuf * name); |
|
|
|
|
|
/* |
|
* OTDeleteNameByID() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTDeleteNameByID( |
|
MapperRef ref, |
|
OTNameID nameID); |
|
|
|
|
|
/* |
|
* OTLookupName() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OSStatus ) |
|
OTLookupName( |
|
MapperRef ref, |
|
TLookupRequest * req, |
|
TLookupReply * reply); |
|
|
|
|
|
/* Basic configuration manipulation*/ |
|
|
|
/* |
|
* OTCreateConfiguration() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientUtilLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OTConfigurationRef ) |
|
OTCreateConfiguration(const char * path); |
|
|
|
|
|
/* |
|
* OTCloneConfiguration() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientUtilLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( OTConfigurationRef ) |
|
OTCloneConfiguration(OTConfigurationRef cfig); |
|
|
|
|
|
/* |
|
* OTDestroyConfiguration() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientUtilLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( void ) |
|
OTDestroyConfiguration(OTConfigurationRef cfig); |
|
|
|
|
|
/* |
|
This file defines a very limited set of operations |
|
on a configuration. "OpenTransportClient.h" extends this with extra |
|
operations used by protocol stacks but not typically needed by clients. |
|
*/ |
|
|
|
/* Interrupt-safe memory allocators*/ |
|
|
|
/* |
|
Under Carbon, OTAllocMem takes a client context pointer. Applications may pass NULL after |
|
calling InitOpenTransport(kInitOTForApplicationMask, ...). Non-applications must always pass a |
|
valid client context. |
|
*/ |
|
/* |
|
* OTAllocMemInContext() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API_C( void * ) |
|
OTAllocMemInContext( |
|
OTByteCount size, |
|
OTClientContextPtr clientContext); /* can be NULL */ |
|
|
|
|
|
#if CALL_NOT_IN_CARBON |
|
/* |
|
* OTAllocMem() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: not available |
|
* CarbonLib: not available |
|
* Mac OS X: not available |
|
*/ |
|
EXTERN_API_C( void * ) |
|
OTAllocMem(OTByteCount size); |
|
|
|
|
|
#endif /* CALL_NOT_IN_CARBON */ |
|
|
|
/* |
|
* OTFreeMem() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientUtilLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API_C( void ) |
|
OTFreeMem(void * mem); |
|
|
|
|
|
#if OTCARBONAPPLICATION |
|
/* The following macros may be used by applications only.*/ |
|
#define OTAllocMem(s) OTAllocMemInContext(s, NULL) |
|
#endif /* OTCARBONAPPLICATION */ |
|
|
|
/* Miscellaneous and Generic Routines*/ |
|
|
|
/* |
|
Neither of these routines should be necessary to the correct |
|
operation of an OT program. If you're calling them, think again. |
|
*/ |
|
|
|
/* |
|
* OTDelay() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( void ) |
|
OTDelay(UInt32 seconds); |
|
|
|
|
|
/* |
|
* OTIdle() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: in OTClientLib 1.0 and later |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API( void ) |
|
OTIdle(void); |
|
|
|
|
|
#endif /* !OTKERNEL */ |
|
|
|
/* |
|
***** Open Transport Utility Routines ***** |
|
All of these routines are available to both client and kernel. |
|
*/ |
|
/* Memory and String Routines*/ |
|
|
|
/* |
|
These are preferable, especially in the kernel case, to the standard |
|
C equivalents because they don't require you to link with StdCLib. |
|
*/ |
|
|
|
/* |
|
* OTMemcpy() |
|
* |
|
* 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 ) |
|
OTMemcpy( |
|
void * dest, |
|
const void * src, |
|
OTByteCount nBytes); |
|
|
|
|
|
/* |
|
* OTMemcmp() |
|
* |
|
* 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 ) |
|
OTMemcmp( |
|
const void * mem1, |
|
const void * mem2, |
|
OTByteCount nBytes); |
|
|
|
|
|
/* |
|
* OTMemmove() |
|
* |
|
* 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 ) |
|
OTMemmove( |
|
void * dest, |
|
const void * src, |
|
OTByteCount nBytes); |
|
|
|
|
|
/* |
|
* OTMemzero() |
|
* |
|
* 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 ) |
|
OTMemzero( |
|
void * dest, |
|
OTByteCount nBytes); |
|
|
|
|
|
/* |
|
* OTMemset() |
|
* |
|
* 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 ) |
|
OTMemset( |
|
void * dest, |
|
OTUInt8Param toSet, |
|
OTByteCount nBytes); |
|
|
|
|
|
/* |
|
* OTStrLength() |
|
* |
|
* 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 ) |
|
OTStrLength(const char * str); |
|
|
|
|
|
/* |
|
* OTStrCopy() |
|
* |
|
* 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 ) |
|
OTStrCopy( |
|
char * dest, |
|
const char * src); |
|
|
|
|
|
/* |
|
* OTStrCat() |
|
* |
|
* 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 ) |
|
OTStrCat( |
|
char * dest, |
|
const char * src); |
|
|
|
|
|
/* |
|
* OTStrEqual() |
|
* |
|
* 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 ) |
|
OTStrEqual( |
|
const char * src1, |
|
const char * src2); |
|
|
|
|
|
/* Timer Utilities*/ |
|
|
|
/* |
|
OTGetTimeStamp returns time in "tick" numbers, stored in 64 bits. |
|
This timestamp can be used as a base number for calculating elapsed |
|
time. |
|
OTSubtractTimeStamps returns a pointer to the "result" parameter. |
|
|
|
OTGetClockTimeInSecs returns time since Open Transport was initialized |
|
in seconds. |
|
*/ |
|
|
|
typedef UnsignedWide OTTimeStamp; |
|
/* |
|
* OTGetTimeStamp() |
|
* |
|
* 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 ) |
|
OTGetTimeStamp(OTTimeStamp * currentTime); |
|
|
|
|
|
/* |
|
* OTSubtractTimeStamps() |
|
* |
|
* 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( OTTimeStamp * ) |
|
OTSubtractTimeStamps( |
|
OTTimeStamp * result, |
|
OTTimeStamp * startTime, |
|
OTTimeStamp * endEnd); |
|
|
|
|
|
/* |
|
* OTTimeStampInMilliseconds() |
|
* |
|
* 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( UInt32 ) |
|
OTTimeStampInMilliseconds(OTTimeStamp * delta); |
|
|
|
|
|
/* |
|
* OTTimeStampInMicroseconds() |
|
* |
|
* 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( UInt32 ) |
|
OTTimeStampInMicroseconds(OTTimeStamp * delta); |
|
|
|
|
|
/* |
|
* OTElapsedMilliseconds() |
|
* |
|
* 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( UInt32 ) |
|
OTElapsedMilliseconds(OTTimeStamp * startTime); |
|
|
|
|
|
/* |
|
* OTElapsedMicroseconds() |
|
* |
|
* 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( UInt32 ) |
|
OTElapsedMicroseconds(OTTimeStamp * startTime); |
|
|
|
|
|
/* |
|
* OTGetClockTimeInSecs() |
|
* |
|
* 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( UInt32 ) |
|
OTGetClockTimeInSecs(void); |
|
|
|
|
|
/* ***** OT Link Element ******/ |
|
|
|
/* |
|
When using OT linked lists, all pointers to other elements are |
|
represented by the OTLink structure. When operating on link |
|
lists, you always pass in the address of the OTLink on which |
|
list elements are chained. |
|
*/ |
|
|
|
struct OTLink { |
|
struct OTLink * fNext; |
|
|
|
#ifdef __cplusplus |
|
|
|
// C++ inline methods on this structure. |
|
|
|
void Init() { fNext = NULL; } |
|
#endif |
|
|
|
|
|
}; |
|
typedef struct OTLink OTLink; |
|
|
|
/* |
|
You can use this macro to map from an OTLink field to the |
|
structure in which it's embedded. |
|
*/ |
|
#define OTGetLinkObject(link, struc, field) \ |
|
((struc*)((char*)(link) - OTOffsetOf(struc, field))) |
|
|
|
/* OTLIFO*/ |
|
|
|
/* |
|
These are functions to implement a LIFO list that is interrupt-safe. |
|
The only function which is not is OTReverseList. Normally, you create |
|
a LIFO list, populate it at interrupt time, and then use OTLIFOStealList |
|
to atomically remove the list, and OTReverseList to flip the list so that |
|
it is a FIFO list, which tends to be more useful. |
|
*/ |
|
|
|
struct OTLIFO { |
|
OTLink * fHead; |
|
|
|
#ifdef __cplusplus |
|
|
|
// C++ inline methods on this structure. |
|
|
|
void Init(); |
|
void Enqueue(OTLink* link); |
|
OTLink* Dequeue(); |
|
OTLink* StealList(); |
|
Boolean IsEmpty(); |
|
#endif |
|
|
|
|
|
}; |
|
typedef struct OTLIFO OTLIFO; |
|
/* |
|
This function atomically enqueues the link onto the |
|
front of the list. |
|
*/ |
|
/* |
|
* OTLIFOEnqueue() |
|
* |
|
* 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 ) |
|
OTLIFOEnqueue( |
|
OTLIFO * list, |
|
OTLink * link); |
|
|
|
|
|
/* |
|
This function atomically dequeues the first element |
|
on the list. |
|
*/ |
|
/* |
|
* OTLIFODequeue() |
|
* |
|
* 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( OTLink * ) |
|
OTLIFODequeue(OTLIFO * list); |
|
|
|
|
|
/* |
|
This function atomically empties the list and returns a |
|
pointer to the first element on the list. |
|
*/ |
|
/* |
|
* OTLIFOStealList() |
|
* |
|
* 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( OTLink * ) |
|
OTLIFOStealList(OTLIFO * list); |
|
|
|
|
|
/* |
|
This function reverses a list that was stolen by |
|
OTLIFOStealList. It is NOT atomic. It returns the |
|
new starting list. |
|
*/ |
|
/* |
|
* OTReverseList() |
|
* |
|
* 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( OTLink * ) |
|
OTReverseList(OTLink * list); |
|
|
|
|
|
|
|
#ifdef __cplusplus |
|
|
|
// C++ inline methods on this structure. |
|
|
|
inline void OTLIFO::Init() { fHead = NULL; } |
|
inline void OTLIFO::Enqueue(OTLink* link) { OTLIFOEnqueue(this, link); } |
|
inline OTLink* OTLIFO::Dequeue() { return OTLIFODequeue(this); } |
|
inline OTLink* OTLIFO::StealList() { return OTLIFOStealList(this); } |
|
inline Boolean OTLIFO::IsEmpty() { return fHead == NULL; } |
|
#endif |
|
|
|
/* OTList*/ |
|
|
|
/* |
|
An OTList is a non-interrupt-safe list, but has more features than the |
|
OTLIFO list. It is a standard singly-linked list. |
|
*/ |
|
|
|
/* |
|
The following is the prototype for a list element comparison function, |
|
which returns true if the element described by linkToCheck matches |
|
the client criteria (typically held in ref). |
|
This is only a UPP for CFM-68K clients. |
|
*/ |
|
|
|
typedef CALLBACK_API_C( Boolean , OTListSearchProcPtr )(const void *ref, OTLink *linkToCheck); |
|
typedef TVECTOR_UPP_TYPE(OTListSearchProcPtr) OTListSearchUPP; |
|
/* |
|
* NewOTListSearchUPP() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: available as macro/inline |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API_C( OTListSearchUPP ) |
|
NewOTListSearchUPP(OTListSearchProcPtr userRoutine); |
|
#if !OPAQUE_UPP_TYPES |
|
enum { uppOTListSearchProcInfo = 0x000003D1 }; /* 1_byte Func(4_bytes, 4_bytes) */ |
|
#ifdef __cplusplus |
|
inline DEFINE_API_C(OTListSearchUPP) NewOTListSearchUPP(OTListSearchProcPtr userRoutine) { return userRoutine; } |
|
#else |
|
#define NewOTListSearchUPP(userRoutine) (userRoutine) |
|
#endif |
|
#endif |
|
|
|
/* |
|
* DisposeOTListSearchUPP() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: available as macro/inline |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API_C( void ) |
|
DisposeOTListSearchUPP(OTListSearchUPP userUPP); |
|
#if !OPAQUE_UPP_TYPES |
|
#ifdef __cplusplus |
|
inline DEFINE_API_C(void) DisposeOTListSearchUPP(OTListSearchUPP) {} |
|
#else |
|
#define DisposeOTListSearchUPP(userUPP) |
|
#endif |
|
#endif |
|
|
|
/* |
|
* InvokeOTListSearchUPP() |
|
* |
|
* Availability: |
|
* Non-Carbon CFM: available as macro/inline |
|
* CarbonLib: in CarbonLib 1.0 and later |
|
* Mac OS X: in version 10.0 and later |
|
*/ |
|
EXTERN_API_C( Boolean ) |
|
InvokeOTListSearchUPP( |
|
const void * ref, |
|
OTLink * linkToCheck, |
|
OTListSearchUPP userUPP); |
|
#if !OPAQUE_UPP_TYPES |
|
#ifdef __cplusplus |
|
inline DEFINE_API_C(Boolean) InvokeOTListSearchUPP(const void * ref, OTLink * linkToCheck, OTListSearchUPP userUPP) { return (*userUPP)(ref, linkToCheck); } |
|
#else |
|
#define InvokeOTListSearchUPP(ref, linkToCheck, userUPP) (*userUPP)(ref, linkToCheck) |
|
#endif |
|
#endif |
|
|
|
struct OTList { |
|
OTLink * fHead; |
|
|
|
#ifdef __cplusplus |
|
// C++ inline methods on this structure. |
|
|
|
void Init(); |
|
Boolean IsEmpty(); |
|
void AddFirst(OTLink* link); |
|
void AddLast(OTLink* link); |
|
OTLink* GetFirst(); |
|
OTLink* GetLast(); |
|
OTLink* RemoveFirst(); |
|
OTLink* RemoveLast(); |
|
Boolean IsInList(OTLink* link); |
|
OTLink* FindLink(OTListSearchUPP proc, const void* ref); |
|
Boolean RemoveLink(OTLink* link); |
|
OTLink* FindAndRemoveLink(OTListSearchUPP proc, const void* ref); |
|
OTLink* GetIndexedLink(OTItemCount index); |
|
#endif |
|
|
|
|
|
}; |
|
typedef struct OTList OTList; |
|
/* Add the link to the list at the front*/ |
|
/* |
|
* OTAddFirst() |
|
* |
|
* 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 ) |
|
OTAddFirst( |
|
OTList * list, |
|
OTLink * link); |
|
|
|
|
|
/* Add the link to the list at the end*/ |
|
/* |
|
* OTAddLast() |
|
* |
|
* 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 ) |
|
OTAddLast( |
|
OTList * list, |
|
OTLink * link); |
|
|
|
|
|
/* Remove the first link from the list*/ |
|
/* |
|
* OTRemoveFirst() |
|
* |
|
* 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( OTLink * ) |
|
OTRemoveFirst(OTList * list); |
|
|
|
|
|
/* Remove the last link from the list*/ |
|
/* |
|
* OTRemoveLast() |
|
* |
|
* 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( OTLink * ) |
|
OTRemoveLast(OTList * list); |
|
|
|
|
|
/* Return the first link from the list*/ |
|
/* |
|
* OTGetFirst() |
|
* |
|
* 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( OTLink * ) |
|
OTGetFirst(OTList * list); |
|
|
|
|
|
/* Return the last link from the list*/ |
|
/* |
|
* OTGetLast() |
|
* |
|
* 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( OTLink * ) |
|
OTGetLast(OTList * list); |
|
|
|
|
|
/* Return true if the link is present in the list*/ |
|
/* |
|
* OTIsInList() |
|
* |
|
* 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 ) |
|
OTIsInList( |
|
OTList * list, |
|
OTLink * link); |
|
|
|
|
|
/* |
|
Find a link in the list which matches the search criteria |
|
established by the search proc and the refPtr. This is done |
|
by calling the search proc, passing it the refPtr and each |
|
link in the list, until the search proc returns true. |
|
NULL is returned if the search proc never returned true. |
|
*/ |
|
/* |
|
* OTFindLink() |
|
* |
|
* 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( OTLink * ) |
|
OTFindLink( |
|
OTList * list, |
|
OTListSearchUPP proc, |
|
const void * ref); |
|
|
|
|
|
/* Remove the specified link from the list, returning true if it was found*/ |
|
/* |
|
* OTRemoveLink() |
|
* |
|
* 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 ) |
|
OTRemoveLink( |
|
OTList * list, |
|
OTLink * link); |
|
|
|
|
|
/* Similar to OTFindLink, but it also removes it from the list.*/ |
|
/* |
|
* OTFindAndRemoveLink() |
|
* |
|
* 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( OTLink * ) |
|
OTFindAndRemoveLink( |
|
OTList * list, |
|
OTListSearchUPP proc, |
|
const void * ref); |
|
|
|
|
|
/* Return the "index"th link in the list*/ |
|
/* |
|
* OTGetIndexedLink() |
|
* |
|
* 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( OTLink * ) |
|
OTGetIndexedLink( |
|
OTList * list, |
|
OTItemCount index); |
|
|
|
|
|
/* OTEnqueue/OTDequeue*/ |
|
|
|
/* |
|
These routines are atomic, mighty weird, and generally not |
|
worth the complexity. If you need atomic list operations, |
|
use OTLIFO instead. |
|
*/ |
|
|
|
/* |
|
This function puts "object" on the listHead, and places the |
|
previous value at listHead into the pointer at "object" plus |
|
linkOffset. |
|
*/ |
|
/* |
|
* OTEnqueue() |
|
* |
|
* 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 ) |
|
OTEnqueue( |
|
void ** listHead, |
|
void * object, |
|
OTByteCount linkOffset); |
|
|
|
|
|
/* |
|
This function returns the head object of the list, and places |
|
the pointer at "object" + linkOffset into the listHead |
|
*/ |
|
/* |
|
* OTDequeue() |
|
* |
|
* 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 * ) |
|
OTDequeue( |
|
void ** listHead, |
|
OTByteCount linkOffset); |
|
|
|
|
|
|
|
#ifdef __cplusplus |
|
// C++ inline methods on this structure. |
|
|
|
inline void OTList::Init() { fHead = NULL; } |
|
inline Boolean OTList::IsEmpty() { return fHead == NULL; } |
|
inline void OTList::AddFirst(OTLink* link) { OTAddFirst(this, link); } |
|
inline void OTList::AddLast(OTLink* link) { OTAddLast(this, link); } |
|
inline OTLink* OTList::GetFirst() { return OTGetFirst(this); } |
|
inline OTLink* OTList::GetLast() { return OTGetLast(this); } |
|
inline OTLink* OTList::RemoveFirst() { return OTRemoveFirst(this); } |
|
inline OTLink* OTList::RemoveLast() { return OTRemoveLast(this); } |
|
inline Boolean OTList::IsInList(OTLink* link) { return OTIsInList(this, link); } |
|
inline OTLink* OTList::FindLink(OTListSearchUPP proc, const void* ref) |
|
{ return OTFindLink(this, proc, ref); } |
|
inline Boolean OTList::RemoveLink(OTLink* link) { return OTRemoveLink(this, link); } |
|
inline OTLink* OTList::FindAndRemoveLink(OTListSearchUPP proc, const void* ref) |
|
{ return OTFindAndRemoveLink(this, proc, ref); } |
|
inline OTLink* OTList::GetIndexedLink(OTItemCount index) |
|
{ return OTGetIndexedLink(this, index); } |
|
#endif |
|
|
|
/* Atomic Operations*/ |
|
|
|
/* |
|
Note: |
|
The Bit operations return the previous value of the bit (0 or non-zero). |
|
The memory pointed to must be a single byte and only bits 0 through 7 are |
|
valid. Bit 0 corresponds to a mask of 0x01, and Bit 7 to a mask of 0x80. |
|
*/ |
|
|
|
/* |
|
WARNING! |
|
void* and UInt32 locations MUST be on 4-byte boundaries. |
|
UInt16 locations must not cross a 4-byte boundary. |
|
*/ |
|
|
|
/* |
|
* OTAtomicSetBit() |
|
* |
|
* 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 |
|
*/ |
|
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM |
|
#pragma parameter __D0 OTAtomicSetBit(__A0, __D0) |
|
#endif |
|
EXTERN_API_C( Boolean ) |
|
OTAtomicSetBit( |
|
UInt8 * bytePtr, |
|
OTByteCount bitNumber) FOURWORDINLINE(0x01D0, 0x56C0, 0x7201, 0xC081); |
|
|
|
|
|
/* |
|
bset.b d0,(a0) |
|
sne d0 |
|
moveq #1,d1 |
|
and.l d1,d0 |
|
*/ |
|
/* |
|
* OTAtomicClearBit() |
|
* |
|
* 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 |
|
*/ |
|
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM |
|
#pragma parameter __D0 OTAtomicClearBit(__A0, __D0) |
|
#endif |
|
EXTERN_API_C( Boolean ) |
|
OTAtomicClearBit( |
|
UInt8 * bytePtr, |
|
OTByteCount bitNumber) FOURWORDINLINE(0x0190, 0x56C0, 0x7201, 0xC081); |
|
|
|
|
|
/* |
|
bclr.b d0,(a0) |
|
sne d0 |
|
moveq #1,d1 |
|
and.l d1,d0 |
|
*/ |
|
/* |
|
* OTAtomicTestBit() |
|
* |
|
* 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 |
|
*/ |
|
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM |
|
#pragma parameter __D0 OTAtomicTestBit(__A0, __D0) |
|
#endif |
|
EXTERN_API_C( Boolean ) |
|
OTAtomicTestBit( |
|
UInt8 * bytePtr, |
|
OTByteCount bitNumber) FOURWORDINLINE(0x0110, 0x56C0, 0x7201, 0xC081); |
|
|
|
|
|
/* |
|
btst.b d0,(a0) |
|
sne d0 *| |
|
moveq #1,d1 |
|
and.l d1,d0 *| |
|
*/ |
|
/* |
|
* OTCompareAndSwapPtr() |
|
* |
|
* 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 |
|
*/ |
|
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM |
|
#pragma parameter __D0 OTCompareAndSwapPtr(__D0, __D1, __A0) |
|
#endif |
|
EXTERN_API_C( Boolean ) |
|
OTCompareAndSwapPtr( |
|
void * oldValue, |
|
void * newValue, |
|
void ** dest) FIVEWORDINLINE(0x0ED0, 0x0040, 0x57C0, 0x7201, 0xC081); |
|
|
|
|
|
/* |
|
cas.l d0,d1,(a0) *| |
|
seq d0 *| |
|
moveq #1,d1; and.l d1,d0 *| |
|
*/ |
|
/* |
|
* OTCompareAndSwap32() |
|
* |
|
* 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 |
|
*/ |
|
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM |
|
#pragma parameter __D0 OTCompareAndSwap32(__D0, __D1, __A0) |
|
#endif |
|
EXTERN_API_C( Boolean ) |
|
OTCompareAndSwap32( |
|
UInt32 oldValue, |
|
UInt32 newValue, |
|
UInt32 * dest) FIVEWORDINLINE(0x0ED0, 0x0040, 0x57C0, 0x7201, 0xC081); |
|
|
|
|
|
/* |
|
cas.l d0,d1,(a0) *| |
|
seq d0 *| |
|
moveq #1,d1; and.l d1,d0 *| |
|
*/ |
|
/* |
|
* OTCompareAndSwap16() |
|
* |
|
* 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 |
|
*/ |
|
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM |
|
#pragma parameter __D0 OTCompareAndSwap16(__D0, __D1, __A0) |
|
#endif |
|
EXTERN_API_C( Boolean ) |
|
OTCompareAndSwap16( |
|
UInt32 oldValue, |
|
UInt32 newValue, |
|
UInt16 * dest) FIVEWORDINLINE(0x0CD0, 0x0040, 0x57C0, 0x7201, 0xC081); |
|
|
|
|
|
/* |
|
cas.w d0,d1,(a0) *| |
|
seq d0 *| |
|
moveq #1,d1; and.l d1,d0 *| |
|
*/ |
|
/* |
|
* OTCompareAndSwap8() |
|
* |
|
* 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 |
|
*/ |
|
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM |
|
#pragma parameter __D0 OTCompareAndSwap8(__D0, __D1, __A0) |
|
#endif |
|
EXTERN_API_C( Boolean ) |
|
OTCompareAndSwap8( |
|
UInt32 oldValue, |
|
UInt32 newValue, |
|
UInt8 * dest) FIVEWORDINLINE(0x0AD0, 0x0040, 0x57C0, 0x7201, 0xC081); |
|
|
|
|
|
/* |
|
cas.b d0,d1,(a0) *| |
|
seq d0 *| |
|
moveq #1,d1; and.l d1,d0 *| |
|
*/ |
|
/* |
|
* OTAtomicAdd32() |
|
* |
|
* 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 |
|
*/ |
|
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM |
|
#pragma parameter __D0 OTAtomicAdd32(__D0, __A0) |
|
#endif |
|
EXTERN_API_C( SInt32 ) |
|
OTAtomicAdd32( |
|
SInt32 toAdd, |
|
SInt32 * dest) SEVENWORDINLINE(0x2240, 0x2210, 0x2001, 0xD089, 0x0ED0, 0x0001, 0x66F4); |
|
|
|
|
|
/* |
|
move.l d0,a1 *| |
|
move.l (a0),d1 *| |
|
move.l d1,d0 *| |
|
add.l a1,d0 *| |
|
cas.l d1,d0,(a0) *| |
|
bne.s @1 *| |
|
*/ |
|
/* |
|
* OTAtomicAdd16() |
|
* |
|
* 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( SInt16 ) |
|
OTAtomicAdd16( |
|
SInt32 toAdd, |
|
SInt16 * dest); |
|
|
|
|
|
/* Not used frequently enough to justify inlining.*/ |
|
/* |
|
* OTAtomicAdd8() |
|
* |
|
* 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( SInt8 ) |
|
OTAtomicAdd8( |
|
SInt32 toAdd, |
|
SInt8 * dest); |
|
|
|
|
|
/* Not used frequently enough to justify inlining.*/ |
|
/* OTLock is just a convenience type with some convenient macros.*/ |
|
|
|
|
|
typedef UInt8 OTLock; |
|
|
|
#define OTClearLock(lockPtr) *(lockPtr) = 0 |
|
#define OTAcquireLock(lockPtr) (OTAtomicSetBit(lockPtr, 0) == 0) |
|
|
|
/******************************************************************************* |
|
** |
|
** FROM HERE ON DOWN ARE THE C++ Interfaces to Open Transport |
|
** |
|
********************************************************************************/ |
|
|
|
#ifdef __cplusplus |
|
} // Terminate C definitions |
|
|
|
/* ------------------------------------------------------------------------- |
|
CLASS TProvider |
|
|
|
This class provides the client interface to a Stream. Typically, clients |
|
talk to an object (or glue code in front of the object) that is a subclass |
|
of TProvider. |
|
------------------------------------------------------------------------- */ |
|
|
|
#if !OTKERNEL |
|
|
|
class TProvider |
|
{ |
|
private: |
|
void* operator new(size_t); |
|
void operator delete(void*) {} |
|
|
|
// |
|
// This is the public interface to a TProvider. All other public |
|
// methods normally come from the subclass. |
|
// |
|
public: |
|
OSStatus Close() { return OTCloseProvider(this); } |
|
|
|
OSStatus SetNonBlocking() { return OTSetNonBlocking(this); } |
|
OSStatus SetBlocking() { return OTSetBlocking(this); } |
|
Boolean IsBlocking() { return OTIsBlocking(this); } |
|
Boolean IsNonBlocking() { return !OTIsBlocking(this); } |
|
OSStatus SetSynchronous() { return OTSetSynchronous(this); } |
|
OSStatus SetAsynchronous() { return OTSetAsynchronous(this); } |
|
Boolean IsSynchronous() { return OTIsSynchronous(this); } |
|
Boolean IsAsynchronous() { return !OTIsSynchronous(this); } |
|
|
|
OSStatus AckSends() { return OTAckSends(this); } |
|
OSStatus DontAckSends() { return OTDontAckSends(this); } |
|
Boolean IsAckingSends() { return OTIsAckingSends(this); } |
|
|
|
void CancelSynchronousCalls(OSStatus err) |
|
{ (void)OTCancelSynchronousCalls(this, err); } |
|
|
|
OSStatus InstallNotifier(OTNotifyUPP proc, void* ptr) |
|
{ return OTInstallNotifier(this, proc, ptr); } |
|
|
|
OSStatus UseSyncIdleEvents() |
|
{ return OTUseSyncIdleEvents(this, true); } |
|
|
|
OSStatus DontUseSyncIdleEvents() |
|
{ return OTUseSyncIdleEvents(this, false); } |
|
|
|
void RemoveNotifier() |
|
{ OTRemoveNotifier(this); } |
|
|
|
Boolean EnterNotifier() |
|
{ return OTEnterNotifier(this); } |
|
|
|
void LeaveNotifier() |
|
{ OTLeaveNotifier(this); } |
|
|
|
#if CALL_NOT_IN_CARBON |
|
OTPortRef GetOTPortRef() |
|
{ return OTGetProviderPortRef(this); } |
|
|
|
ProviderRef TransferOwnership(OTClient prevOwner, OSStatus* errPtr) |
|
{ return OTTransferProviderOwnership(this, prevOwner, errPtr); } |
|
#endif |
|
|
|
SInt32 Ioctl(UInt32 cmd, void* data) |
|
{ return OTIoctl(this, cmd, data); } |
|
SInt32 Ioctl(UInt32 cmd, long data) |
|
{ return OTIoctl(this, cmd, (void*)data); } |
|
|
|
#if CALL_NOT_IN_CARBON |
|
OTResult GetMessage(strbuf* ctlbuf, strbuf* databuf, OTFlags* flagPtr) |
|
{ return OTGetMessage(this, ctlbuf, databuf, flagPtr); } |
|
OTResult GetPriorityMessage(strbuf* ctlbuf, strbuf* databuf, |
|
OTBand* bandPtr, OTFlags* flagPtr) |
|
{ return OTGetPriorityMessage(this, ctlbuf, databuf, bandPtr, flagPtr); } |
|
OSStatus PutMessage(const strbuf* ctlbuf, const strbuf* databuf, |
|
OTFlags flags) |
|
{ return OTPutMessage(this, ctlbuf, databuf, flags); } |
|
OSStatus PutPriorityMessage(const strbuf* ctlbuf, const strbuf* databuf, |
|
OTBand band, OTFlags flags) |
|
{ return OTPutPriorityMessage(this, ctlbuf, databuf, band, flags); } |
|
#endif |
|
|
|
}; |
|
|
|
|
|
/* ------------------------------------------------------------------------- |
|
Class TEndpoint |
|
|
|
This class is the interface to all TPI modules, which constitute the |
|
vast majority of protocols, with the exception of link-layer protocols. |
|
------------------------------------------------------------------------- */ |
|
|
|
class TEndpoint : public TProvider |
|
{ |
|
public: |
|
// |
|
// Miscellaneous informative functions |
|
// |
|
OSStatus GetEndpointInfo(TEndpointInfo* info) |
|
{ return OTGetEndpointInfo(this, info); } |
|
|
|
OSStatus GetProtAddress(TBind* boundAddr, TBind* peerAddr) |
|
{ return OTGetProtAddress(this, boundAddr, peerAddr); } |
|
|
|
OSStatus ResolveAddress(TBind* reqAddr, TBind* retAddr, OTTimeout timeout) |
|
{ return OTResolveAddress(this, reqAddr, retAddr, timeout); } |
|
|
|
OTResult GetEndpointState() |
|
{ return OTGetEndpointState(this); } |
|
|
|
OTResult Look() |
|
{ return OTLook(this); } |
|
|
|
#if CALL_NOT_IN_CARBON |
|
OTResult Sync() |
|
{ return OTSync(this); } |
|
#endif |
|
// |
|
// Allocating structures |
|
// |
|
void* AllocInContext(OTStructType structType, UInt32 fields, OSStatus* err = NULL, OTClientContextPtr clientContext = NULL) |
|
{ return OTAllocInContext(this, structType, fields, err, clientContext); } |
|
|
|
void* Alloc(OTStructType structType, UInt32 fields, OSStatus* err = NULL) |
|
{ |
|
#if TARGET_API_MAC_CARBON |
|
return OTAllocInContext(this, structType, fields, err, NULL); |
|
#else |
|
return OTAlloc(this, structType, fields, err); |
|
#endif |
|
}; |
|
|
|
OTResult Free(void* ptr, OTStructType structType) |
|
{ return OTFree(ptr, structType); } |
|
// |
|
// Option Management |
|
// |
|
OSStatus OptionManagement(TOptMgmt* req, TOptMgmt* ret) |
|
{ return OTOptionManagement(this, req, ret); } |
|
// |
|
// Bind/Unbind |
|
// |
|
OSStatus Bind(TBind* reqAddr, TBind* retAddr) |
|
{ return OTBind(this, reqAddr, retAddr); } |
|
|
|
OSStatus Unbind() |
|
{ return OTUnbind(this); } |
|
// |
|
// Connection creation and tear-down |
|
// |
|
OSStatus Connect(TCall* sndCall, TCall* rcvCall) |
|
{ return OTConnect(this, sndCall, rcvCall); } |
|
|
|
OSStatus RcvConnect(TCall* call) |
|
{ return OTRcvConnect(this, call); } |
|
|
|
OSStatus Listen(TCall* call) |
|
{ return OTListen(this, call); } |
|
|
|
OSStatus Accept(EndpointRef resRef, TCall* call) |
|
{ return OTAccept(this, resRef, call); } |
|
|
|
OSStatus SndDisconnect(TCall* call) |
|
{ return OTSndDisconnect(this, call); } |
|
|
|
OSStatus SndOrderlyDisconnect() |
|
{ return OTSndOrderlyDisconnect(this); } |
|
|
|
OSStatus RcvDisconnect(TDiscon* discon) |
|
{ return OTRcvDisconnect(this, discon); } |
|
|
|
OSStatus RcvOrderlyDisconnect() |
|
{ return OTRcvOrderlyDisconnect(this); } |
|
// |
|
// Connection-oriented data transfer |
|
// |
|
OTResult Snd(void* buf, OTByteCount nbytes, OTFlags flags) |
|
{ return OTSnd(this, buf, nbytes, flags); } |
|
|
|
OTResult Rcv(void* buf, OTByteCount nbytes, OTFlags* flagP) |
|
{ return OTRcv(this, buf, nbytes, flagP); } |
|
// |
|
// Non-connection-oriented data transfer |
|
// |
|
OSStatus SndUData(TUnitData* udata) |
|
{ return OTSndUData(this, udata); } |
|
|
|
OSStatus RcvUData(TUnitData* udata, OTFlags* flagP) |
|
{ return OTRcvUData(this, udata, flagP); } |
|
|
|
OSStatus RcvUDErr(TUDErr* uderr) |
|
{ return OTRcvUDErr(this, uderr); } |
|
|
|
#if CALL_NOT_IN_CARBON |
|
// |
|
// Connection-oriented transactions |
|
// |
|
OSStatus SndRequest(TRequest* req, OTFlags reqFlags) |
|
{ return OTSndRequest(this, req, reqFlags); } |
|
|
|
OSStatus RcvReply(TReply* reply, OTFlags* replyFlags) |
|
{ return OTRcvReply(this, reply, replyFlags); } |
|
|
|
OSStatus SndReply(TReply* reply, OTFlags flags) |
|
{ return OTSndReply(this, reply, flags); } |
|
|
|
OSStatus RcvRequest(TRequest* req, OTFlags* flags) |
|
{ return OTRcvRequest(this, req, flags); } |
|
|
|
OSStatus CancelRequest(OTSequence seq) |
|
{ return OTCancelRequest(this, seq); } |
|
|
|
OSStatus CancelReply(OTSequence seq) |
|
{ return OTCancelReply(this, seq); } |
|
// |
|
// Non-connection-oriented transactions |
|
// |
|
OSStatus SndURequest(TUnitRequest* req, OTFlags reqFlags) |
|
{ return OTSndURequest(this, req, reqFlags); } |
|
|
|
OSStatus RcvUReply(TUnitReply* reply, OTFlags* replyFlags) |
|
{ return OTRcvUReply(this, reply, replyFlags); } |
|
|
|
OSStatus SndUReply(TUnitReply* reply, OTFlags flags) |
|
{ return OTSndUReply(this, reply, flags); } |
|
|
|
OSStatus RcvURequest(TUnitRequest* req, OTFlags* flags) |
|
{ return OTRcvURequest(this, req, flags); } |
|
|
|
OSStatus CancelURequest(OTSequence seq) |
|
{ return OTCancelURequest(this, seq); } |
|
|
|
OSStatus CancelUReply(OTSequence seq) |
|
{ return OTCancelUReply(this, seq); } |
|
#endif |
|
// |
|
// Miscellaneous functions |
|
// |
|
OTResult CountDataBytes(OTByteCount* countPtr) |
|
{ return OTCountDataBytes(this, countPtr); } |
|
}; |
|
|
|
/* ------------------------------------------------------------------------- |
|
CLASS TMapper |
|
|
|
This class is the interface to naming protocols. |
|
------------------------------------------------------------------------- */ |
|
|
|
class TMapper : public TProvider |
|
{ |
|
public: |
|
OSStatus RegisterName(TRegisterRequest* req, TRegisterReply* reply) |
|
{ return OTRegisterName(this, req, reply); } |
|
|
|
OSStatus DeleteName(TNetbuf* name) |
|
{ return OTDeleteName(this, name); } |
|
|
|
OSStatus DeleteName(OTNameID theID) |
|
{ return OTDeleteNameByID(this, theID); } |
|
|
|
OSStatus LookupName(TLookupRequest* req, TLookupReply* reply) |
|
{ return OTLookupName(this, req, reply); } |
|
}; |
|
|
|
#endif /* !OTKERNEL */ |
|
|
|
extern "C" { // resume C definitions |
|
#endif /* __cplusplus */ |
|
|
|
|
|
#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 /* __OPENTRANSPORT__ */ |
|
|
|
|