d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
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.
406 Commits
25 Branches
6 Tags
221 MiB
Tree: 70cc94bd01
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '70cc94bd01'
${ noResults }
source-engine/common/quicktime_win32/OpenTransport.h

4832 lines
142 KiB
Raw Normal View History Unescape

1
5 years ago
/*
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__ */