Initial source

1 files changed, 750 insertions, 0 deletions

diff --git a/include/mach/message.h b/include/mach/message.h
new file mode 100644
index 0000000..8f1860f
--- /dev/null
+++ b/include/mach/message.h
@@ -0,0 +1,750 @@
+/* 
+ * Mach Operating System
+ * Copyright (c) 1992-1987 Carnegie Mellon University
+ * All Rights Reserved.
+ * 
+ * Permission to use, copy, modify and distribute this software and its
+ * documentation is hereby granted, provided that both the copyright
+ * notice and this permission notice appear in all copies of the
+ * software, derivative works or modified versions, and any portions
+ * thereof, and that both notices appear in supporting documentation.
+ * 
+ * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
+ * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
+ * 
+ * Carnegie Mellon requests users of this software to return to
+ * 
+ *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
+ *  School of Computer Science
+ *  Carnegie Mellon University
+ *  Pittsburgh PA 15213-3890
+ * 
+ * any improvements or extensions that they make and grant Carnegie Mellon
+ * the rights to redistribute these changes.
+ */
+/*
+ *	File:	mach/message.h
+ *
+ *	Mach IPC message and primitive function definitions.
+ */
+
+#ifndef	_MACH_MESSAGE_H_
+#define _MACH_MESSAGE_H_
+
+#ifdef	MACH_KERNEL
+#include <mach_ipc_compat.h>
+#endif	/* MACH_KERNEL */
+
+#include <mach/kern_return.h>
+#include <mach/port.h>
+
+
+/*
+ *  The timeout mechanism uses mach_msg_timeout_t values,
+ *  passed by value.  The timeout units are milliseconds.
+ *  It is controlled with the MACH_SEND_TIMEOUT
+ *  and MACH_RCV_TIMEOUT options.
+ */
+
+typedef natural_t mach_msg_timeout_t;
+
+/*
+ *  The value to be used when there is no timeout.
+ *  (No MACH_SEND_TIMEOUT/MACH_RCV_TIMEOUT option.)
+ */
+
+#define MACH_MSG_TIMEOUT_NONE		((mach_msg_timeout_t) 0)
+
+/*
+ *  The kernel uses MACH_MSGH_BITS_COMPLEX as a hint.  It it isn't on, it
+ *  assumes the body of the message doesn't contain port rights or OOL
+ *  data.  The field is set in received messages.  A user task must
+ *  use caution in interpreting the body of a message if the bit isn't
+ *  on, because the mach_msg_type's in the body might "lie" about the
+ *  contents.  If the bit isn't on, but the mach_msg_types
+ *  in the body specify rights or OOL data, the behaviour is undefined.
+ *  (Ie, an error may or may not be produced.)
+ *
+ *  The value of MACH_MSGH_BITS_REMOTE determines the interpretation
+ *  of the msgh_remote_port field.  It is handled like a msgt_name.
+ *
+ *  The value of MACH_MSGH_BITS_LOCAL determines the interpretation
+ *  of the msgh_local_port field.  It is handled like a msgt_name.
+ *
+ *  MACH_MSGH_BITS() combines two MACH_MSG_TYPE_* values, for the remote
+ *  and local fields, into a single value suitable for msgh_bits.
+ *
+ *  MACH_MSGH_BITS_COMPLEX_PORTS, MACH_MSGH_BITS_COMPLEX_DATA, and
+ *  MACH_MSGH_BITS_CIRCULAR should be zero; they are used internally.
+ *
+ *  The unused bits should be zero.
+ */
+
+#define MACH_MSGH_BITS_ZERO		0x00000000
+#define MACH_MSGH_BITS_REMOTE_MASK	0x000000ff
+#define MACH_MSGH_BITS_LOCAL_MASK	0x0000ff00
+#define MACH_MSGH_BITS_COMPLEX		0x80000000U
+#define	MACH_MSGH_BITS_CIRCULAR		0x40000000	/* internal use only */
+#define	MACH_MSGH_BITS_COMPLEX_PORTS	0x20000000	/* internal use only */
+#define	MACH_MSGH_BITS_COMPLEX_DATA	0x10000000	/* internal use only */
+#define	MACH_MSGH_BITS_MIGRATED		0x08000000	/* internal use only */
+#define	MACH_MSGH_BITS_UNUSED		0x07ff0000
+
+#define	MACH_MSGH_BITS_PORTS_MASK				\
+		(MACH_MSGH_BITS_REMOTE_MASK|MACH_MSGH_BITS_LOCAL_MASK)
+
+#define MACH_MSGH_BITS(remote, local)				\
+		((remote) | ((local) << 8))
+#define	MACH_MSGH_BITS_REMOTE(bits)				\
+		((bits) & MACH_MSGH_BITS_REMOTE_MASK)
+#define	MACH_MSGH_BITS_LOCAL(bits)				\
+		(((bits) & MACH_MSGH_BITS_LOCAL_MASK) >> 8)
+#define	MACH_MSGH_BITS_PORTS(bits)				\
+		((bits) & MACH_MSGH_BITS_PORTS_MASK)
+#define	MACH_MSGH_BITS_OTHER(bits)				\
+		((bits) &~ MACH_MSGH_BITS_PORTS_MASK)
+
+/*
+ *  Every message starts with a message header.
+ *  Following the message header are zero or more pairs of
+ *  type descriptors (mach_msg_type_t/mach_msg_type_long_t) and
+ *  data values.  The size of the message must be specified in bytes,
+ *  and includes the message header, type descriptors, inline
+ *  data, and inline pointer for out-of-line data.
+ *
+ *  The msgh_remote_port field specifies the destination of the message.
+ *  It must specify a valid send or send-once right for a port.
+ *
+ *  The msgh_local_port field specifies a "reply port".  Normally,
+ *  This field carries a send-once right that the receiver will use
+ *  to reply to the message.  It may carry the values MACH_PORT_NULL,
+ *  MACH_PORT_DEAD, a send-once right, or a send right.
+ *
+ *  The msgh_seqno field carries a sequence number associated with the
+ *  received-from port.  A port's sequence number is incremented every
+ *  time a message is received from it.  In sent messages, the field's
+ *  value is ignored.
+ *
+ *  The msgh_id field is uninterpreted by the message primitives.
+ *  It normally carries information specifying the format
+ *  or meaning of the message.
+ */
+
+typedef unsigned int mach_msg_bits_t;
+typedef	unsigned int mach_msg_size_t;
+typedef natural_t mach_msg_seqno_t;
+typedef integer_t mach_msg_id_t;
+
+typedef	struct {
+    mach_msg_bits_t	msgh_bits;
+    mach_msg_size_t	msgh_size;
+    mach_port_t		msgh_remote_port;
+    mach_port_t		msgh_local_port;
+    mach_port_seqno_t	msgh_seqno;
+    mach_msg_id_t	msgh_id;
+} mach_msg_header_t;
+
+/*
+ *  There is no fixed upper bound to the size of Mach messages.
+ */
+
+#define	MACH_MSG_SIZE_MAX	((mach_msg_size_t) ~0)
+
+/*
+ *  Compatibility definitions, for code written
+ *  when there was a msgh_kind instead of msgh_seqno.
+ */
+
+#define MACH_MSGH_KIND_NORMAL		0x00000000
+#if	0
+/* code using this is likely to break, so better not to have it defined */
+#define MACH_MSGH_KIND_NOTIFICATION	0x00000001
+#endif
+#define	msgh_kind			msgh_seqno
+#define mach_msg_kind_t			mach_port_seqno_t
+
+/*
+ *  The msgt_number field specifies the number of data elements.
+ *  The msgt_size field specifies the size of each data element, in bits.
+ *  The msgt_name field specifies the type of each data element.
+ *  If msgt_inline is TRUE, the data follows the type descriptor
+ *  in the body of the message.  If msgt_inline is FALSE, then a pointer
+ *  to the data should follow the type descriptor, and the data is
+ *  sent out-of-line.  In this case, if msgt_deallocate is TRUE,
+ *  then the out-of-line data is moved (instead of copied) into the message.
+ *  If msgt_longform is TRUE, then the type descriptor is actually
+ *  a mach_msg_type_long_t.
+ *
+ *  The actual amount of inline data following the descriptor must
+ *  a multiple of the word size.  For out-of-line data, this is a
+ *  pointer.  For inline data, the supplied data size (calculated
+ *  from msgt_number/msgt_size) is rounded up.  This guarantees
+ *  that type descriptors always fall on word boundaries.
+ *
+ *  For port rights, msgt_size must be 8*sizeof(mach_port_t).
+ *  If the data is inline, msgt_deallocate should be FALSE.
+ *  The msgt_unused bit should be zero.
+ *  The msgt_name, msgt_size, msgt_number fields in
+ *  a mach_msg_type_long_t should be zero.
+ */
+
+typedef unsigned int mach_msg_type_name_t;
+typedef unsigned int mach_msg_type_size_t;
+typedef natural_t  mach_msg_type_number_t;
+
+typedef struct  {
+    unsigned int	msgt_name : 8,
+			msgt_size : 8,
+			msgt_number : 12,
+			msgt_inline : 1,
+			msgt_longform : 1,
+			msgt_deallocate : 1,
+			msgt_unused : 1;
+} mach_msg_type_t;
+
+typedef	struct	{
+    mach_msg_type_t	msgtl_header;
+    unsigned short	msgtl_name;
+    unsigned short	msgtl_size;
+    natural_t		msgtl_number;
+} mach_msg_type_long_t;
+
+
+/*
+ *	Known values for the msgt_name field.
+ *
+ *	The only types known to the Mach kernel are
+ *	the port types, and those types used in the
+ *	kernel RPC interface.
+ */
+
+#define MACH_MSG_TYPE_UNSTRUCTURED	0
+#define MACH_MSG_TYPE_BIT		0
+#define MACH_MSG_TYPE_BOOLEAN		0
+#define MACH_MSG_TYPE_INTEGER_16	1
+#define MACH_MSG_TYPE_INTEGER_32	2
+#define MACH_MSG_TYPE_CHAR		8
+#define MACH_MSG_TYPE_BYTE		9
+#define MACH_MSG_TYPE_INTEGER_8		9
+#define MACH_MSG_TYPE_REAL		10
+#define MACH_MSG_TYPE_INTEGER_64	11
+#define MACH_MSG_TYPE_STRING		12
+#define MACH_MSG_TYPE_STRING_C		12
+
+/*
+ *  Values used when sending a port right.
+ */
+
+#define MACH_MSG_TYPE_MOVE_RECEIVE	16	/* Must hold receive rights */
+#define MACH_MSG_TYPE_MOVE_SEND		17	/* Must hold send rights */
+#define MACH_MSG_TYPE_MOVE_SEND_ONCE	18	/* Must hold sendonce rights */
+#define MACH_MSG_TYPE_COPY_SEND		19	/* Must hold send rights */
+#define MACH_MSG_TYPE_MAKE_SEND		20	/* Must hold receive rights */
+#define MACH_MSG_TYPE_MAKE_SEND_ONCE	21	/* Must hold receive rights */
+
+/*
+ *  Values received/carried in messages.  Tells the receiver what
+ *  sort of port right he now has.
+ *
+ *  MACH_MSG_TYPE_PORT_NAME is used to transfer a port name
+ *  which should remain uninterpreted by the kernel.  (Port rights
+ *  are not transferred, just the port name.)
+ */
+
+#define MACH_MSG_TYPE_PORT_NAME		15
+#define MACH_MSG_TYPE_PORT_RECEIVE	MACH_MSG_TYPE_MOVE_RECEIVE
+#define MACH_MSG_TYPE_PORT_SEND		MACH_MSG_TYPE_MOVE_SEND
+#define MACH_MSG_TYPE_PORT_SEND_ONCE	MACH_MSG_TYPE_MOVE_SEND_ONCE
+
+#define MACH_MSG_TYPE_LAST		22		/* Last assigned */
+
+/*
+ *  A dummy value.  Mostly used to indicate that the actual value
+ *  will be filled in later, dynamically.
+ */
+
+#define MACH_MSG_TYPE_POLYMORPHIC	((mach_msg_type_name_t) -1)
+
+/*
+ *	Is a given item a port type?
+ */
+
+#define MACH_MSG_TYPE_PORT_ANY(x)			\
+	(((x) >= MACH_MSG_TYPE_MOVE_RECEIVE) &&		\
+	 ((x) <= MACH_MSG_TYPE_MAKE_SEND_ONCE))
+
+#define	MACH_MSG_TYPE_PORT_ANY_SEND(x)			\
+	(((x) >= MACH_MSG_TYPE_MOVE_SEND) &&		\
+	 ((x) <= MACH_MSG_TYPE_MAKE_SEND_ONCE))
+
+#define	MACH_MSG_TYPE_PORT_ANY_RIGHT(x)			\
+	(((x) >= MACH_MSG_TYPE_MOVE_RECEIVE) &&		\
+	 ((x) <= MACH_MSG_TYPE_MOVE_SEND_ONCE))
+
+typedef integer_t mach_msg_option_t;
+
+#define MACH_MSG_OPTION_NONE	0x00000000
+
+#define	MACH_SEND_MSG		0x00000001
+#define	MACH_RCV_MSG		0x00000002
+
+#define MACH_SEND_TIMEOUT	0x00000010
+#define MACH_SEND_NOTIFY	0x00000020
+#define MACH_SEND_INTERRUPT	0x00000040	/* libmach implements */
+#define MACH_SEND_CANCEL	0x00000080
+#define MACH_RCV_TIMEOUT	0x00000100
+#define MACH_RCV_NOTIFY		0x00000200
+#define MACH_RCV_INTERRUPT	0x00000400	/* libmach implements */
+#define MACH_RCV_LARGE		0x00000800
+
+#define MACH_SEND_ALWAYS	0x00010000	/* internal use only */
+
+
+/*
+ *  Much code assumes that mach_msg_return_t == kern_return_t.
+ *  This definition is useful for descriptive purposes.
+ *
+ *  See <mach/error.h> for the format of error codes.
+ *  IPC errors are system 4.  Send errors are subsystem 0;
+ *  receive errors are subsystem 1.  The code field is always non-zero.
+ *  The high bits of the code field communicate extra information
+ *  for some error codes.  MACH_MSG_MASK masks off these special bits.
+ */
+
+typedef kern_return_t mach_msg_return_t;
+
+#define MACH_MSG_SUCCESS		0x00000000
+
+#define	MACH_MSG_MASK			0x00003c00
+		/* All special error code bits defined below. */
+#define	MACH_MSG_IPC_SPACE		0x00002000
+		/* No room in IPC name space for another capability name. */
+#define	MACH_MSG_VM_SPACE		0x00001000
+		/* No room in VM address space for out-of-line memory. */
+#define	MACH_MSG_IPC_KERNEL		0x00000800
+		/* Kernel resource shortage handling an IPC capability. */
+#define	MACH_MSG_VM_KERNEL		0x00000400
+		/* Kernel resource shortage handling out-of-line memory. */
+
+#define MACH_SEND_IN_PROGRESS		0x10000001
+		/* Thread is waiting to send.  (Internal use only.) */
+#define MACH_SEND_INVALID_DATA		0x10000002
+		/* Bogus in-line data. */
+#define MACH_SEND_INVALID_DEST		0x10000003
+		/* Bogus destination port. */
+#define MACH_SEND_TIMED_OUT		0x10000004
+		/* Message not sent before timeout expired. */
+#define MACH_SEND_WILL_NOTIFY		0x10000005
+		/* Msg-accepted notification will be generated. */
+#define MACH_SEND_NOTIFY_IN_PROGRESS	0x10000006
+		/* Msg-accepted notification already pending. */
+#define MACH_SEND_INTERRUPTED		0x10000007
+		/* Software interrupt. */
+#define MACH_SEND_MSG_TOO_SMALL		0x10000008
+		/* Data doesn't contain a complete message. */
+#define MACH_SEND_INVALID_REPLY		0x10000009
+		/* Bogus reply port. */
+#define MACH_SEND_INVALID_RIGHT		0x1000000a
+		/* Bogus port rights in the message body. */
+#define MACH_SEND_INVALID_NOTIFY	0x1000000b
+		/* Bogus notify port argument. */
+#define MACH_SEND_INVALID_MEMORY	0x1000000c
+		/* Invalid out-of-line memory pointer. */
+#define MACH_SEND_NO_BUFFER		0x1000000d
+		/* No message buffer is available. */
+#define MACH_SEND_NO_NOTIFY		0x1000000e
+		/* Resource shortage; can't request msg-accepted notif. */
+#define MACH_SEND_INVALID_TYPE		0x1000000f
+		/* Invalid msg-type specification. */
+#define MACH_SEND_INVALID_HEADER	0x10000010
+		/* A field in the header had a bad value. */
+
+#define MACH_RCV_IN_PROGRESS		0x10004001
+		/* Thread is waiting for receive.  (Internal use only.) */
+#define MACH_RCV_INVALID_NAME		0x10004002
+		/* Bogus name for receive port/port-set. */
+#define MACH_RCV_TIMED_OUT		0x10004003
+		/* Didn't get a message within the timeout value. */
+#define MACH_RCV_TOO_LARGE		0x10004004
+		/* Message buffer is not large enough for inline data. */
+#define MACH_RCV_INTERRUPTED		0x10004005
+		/* Software interrupt. */
+#define MACH_RCV_PORT_CHANGED		0x10004006
+		/* Port moved into a set during the receive. */
+#define MACH_RCV_INVALID_NOTIFY		0x10004007
+		/* Bogus notify port argument. */
+#define MACH_RCV_INVALID_DATA		0x10004008
+		/* Bogus message buffer for inline data. */
+#define MACH_RCV_PORT_DIED		0x10004009
+		/* Port/set was sent away/died during receive. */
+#define	MACH_RCV_IN_SET			0x1000400a
+		/* Port is a member of a port set. */
+#define	MACH_RCV_HEADER_ERROR		0x1000400b
+		/* Error receiving message header.  See special bits. */
+#define	MACH_RCV_BODY_ERROR		0x1000400c
+		/* Error receiving message body.  See special bits. */
+
+
+extern mach_msg_return_t
+mach_msg_trap
+#if	defined(c_plusplus) || defined(__STDC__)
+   (mach_msg_header_t *msg,
+    mach_msg_option_t option,
+    mach_msg_size_t send_size,
+    mach_msg_size_t rcv_size,
+    mach_port_t rcv_name,
+    mach_msg_timeout_t timeout,
+    mach_port_t notify);
+#else	/* c_plusplus || __STDC__ */
+#ifdef	LINTLIBRARY
+   (msg, option, send_size, rcv_size, rcv_name, timeout, notify)
+    mach_msg_header_t *msg;
+    mach_msg_option_t option;
+    mach_msg_size_t send_size;
+    mach_msg_size_t rcv_size
+    mach_port_t rcv_name;
+    mach_msg_timeout_t timeout;
+    mach_port_t notify;
+{ return MACH_RCV_SUCCESS; }
+#else	/* LINTLIBRARY */
+   ();
+#endif	/* LINTLIBRARY */
+#endif	/* c_plusplus || __STDC__ */
+
+extern mach_msg_return_t
+mach_msg
+#if	defined(c_plusplus) || defined(__STDC__)
+   (mach_msg_header_t *msg,
+    mach_msg_option_t option,
+    mach_msg_size_t send_size,
+    mach_msg_size_t rcv_size,
+    mach_port_t rcv_name,
+    mach_msg_timeout_t timeout,
+    mach_port_t notify);
+#else	/* c_plusplus || __STDC__ */
+#ifdef	LINTLIBRARY
+   (msg, option, send_size, rcv_size, rcv_name, timeout, notify)
+    mach_msg_header_t *msg;
+    mach_msg_option_t option;
+    mach_msg_size_t send_size;
+    mach_msg_size_t rcv_size
+    mach_port_t rcv_name;
+    mach_msg_timeout_t timeout;
+    mach_port_t notify;
+{ return MACH_RCV_SUCCESS; }
+#else	/* LINTLIBRARY */
+   ();
+#endif	/* LINTLIBRARY */
+#endif	/* c_plusplus || __STDC__ */
+
+
+/* Definitions for the old IPC interface. */
+
+#if	MACH_IPC_COMPAT
+
+/*
+ *	Message data structures.
+ *
+ *	Messages consist of two parts: a fixed-size header, immediately
+ *	followed by a variable-size array of typed data items.
+ *
+ */
+
+typedef	unsigned int	msg_size_t;
+
+typedef	struct {
+		unsigned int	msg_unused : 24,
+				msg_simple : 8;
+		msg_size_t	msg_size;
+		integer_t	msg_type;
+		port_t		msg_local_port;
+		port_t		msg_remote_port;
+		integer_t	msg_id;
+} msg_header_t;
+
+#define MSG_SIZE_MAX	8192
+
+/*
+ *	Known values for the msg_type field.
+ *	These are Accent holdovers, which should be purged when possible.
+ *
+ *	Only one bit in the msg_type field is used by the kernel.
+ *	Others are available to user applications.  See <msg_type.h>
+ *	for system application-assigned values.
+ */
+
+#define MSG_TYPE_NORMAL		0
+#define MSG_TYPE_EMERGENCY	1
+
+/*
+ *	Each data item is preceded by a description of that
+ *	item, including what type of data, how big it is, and
+ *	how many of them are present.
+ *
+ *	The actual data will either follow this type
+ *	descriptor ("inline") or will be specified by a pointer.
+ *
+ *	If the type name, size, or number is too large to be encoded
+ *	in this structure, the "longform" option may be selected,
+ *	and those fields must immediately follow in full integer fields.
+ *
+ *	For convenience, out-of-line data regions or port rights may
+ *	be deallocated when the message is sent by specifying the
+ *	"deallocate" field.  Beware: if the data item in question is both
+ *	out-of-line and contains port rights, then both will be deallocated.
+ */
+
+typedef struct  {
+	unsigned int	msg_type_name : 8,		/* What kind of data */
+			msg_type_size : 8,		/* How many bits is each item */
+			msg_type_number : 12,		/* How many items are there */
+			msg_type_inline : 1,		/* If true, data follows; else a pointer */
+			msg_type_longform : 1,		/* Name, size, number follow: see above */
+			msg_type_deallocate : 1,	/* Deallocate port rights or memory */
+			msg_type_unused : 1;
+} msg_type_t;
+
+typedef	struct	{
+	msg_type_t	msg_type_header;
+	unsigned short	msg_type_long_name;
+	unsigned short	msg_type_long_size;
+	natural_t	msg_type_long_number;
+} msg_type_long_t;
+
+/*
+ *	Known values for the msg_type_name field.
+ *
+ *	The only types known to the Mach kernel are
+ *	the port types, and those types used in the
+ *	kernel RPC interface.
+ */
+
+#define MSG_TYPE_UNSTRUCTURED	0
+#define MSG_TYPE_BIT		0
+#define MSG_TYPE_BOOLEAN	0
+#define MSG_TYPE_INTEGER_16	1
+#define MSG_TYPE_INTEGER_32	2
+#define MSG_TYPE_PORT_OWNERSHIP	3	/* obsolete */
+#define MSG_TYPE_PORT_RECEIVE	4	/* obsolete */
+#define MSG_TYPE_PORT_ALL	5
+#define MSG_TYPE_PORT		6
+#define MSG_TYPE_CHAR		8
+#define MSG_TYPE_BYTE		9
+#define MSG_TYPE_INTEGER_8	9
+#define MSG_TYPE_REAL		10
+#define MSG_TYPE_STRING		12
+#define MSG_TYPE_STRING_C	12
+/*	MSG_TYPE_INVALID	13	unused */
+
+#define MSG_TYPE_INTERNAL_MEMORY MSG_TYPE_INTEGER_8
+
+#define MSG_TYPE_PORT_NAME	15		/* A capability name */
+#define MSG_TYPE_LAST		16		/* Last assigned */
+
+#define MSG_TYPE_POLYMORPHIC	((unsigned int) -1)
+
+/*
+ *	Is a given item a port type?
+ */
+
+#define MSG_TYPE_PORT_ANY(x)	\
+	(((x) == MSG_TYPE_PORT) || ((x) == MSG_TYPE_PORT_ALL))
+
+/*
+ *	Other basic types
+ */
+
+typedef natural_t	msg_timeout_t;
+
+/*
+ *	Options to IPC primitives.
+ *
+ *	These can be combined by or'ing; the combination RPC call
+ *	uses both SEND_ and RCV_ options at once.
+ */
+
+typedef	integer_t		msg_option_t;
+
+#define MSG_OPTION_NONE	0x0000	/* Terminate only when message op works */
+
+#define SEND_TIMEOUT	0x0001	/* Terminate on timeout elapsed */
+#define SEND_NOTIFY	0x0002	/* Terminate with reply message if need be */
+
+#define SEND_INTERRUPT	0x0004	/* Terminate on software interrupt */
+
+#define RCV_TIMEOUT	0x0100	/* Terminate on timeout elapsed */
+#define RCV_NO_SENDERS	0x0200	/* Terminate if I'm the only sender left */
+#define RCV_INTERRUPT	0x0400	/* Terminate on software interrupt */
+
+/*
+ *	Returns from IPC primitives.
+ *
+ *	Values are separate in order to allow RPC users to
+ *	distinguish which operation failed; for successful completion,
+ *	this doesn't matter.
+ */
+
+typedef	int		msg_return_t;
+
+#define SEND_SUCCESS		0
+
+#define SEND_ERRORS_START	-100
+#define SEND_INVALID_MEMORY	-101	/* Message or OOL data invalid */
+#define SEND_INVALID_PORT	-102	/* Reference to inacessible port */
+#define SEND_TIMED_OUT		-103	/* Terminated due to timeout */
+#define SEND_WILL_NOTIFY	-105	/* Msg accepted provisionally */
+#define SEND_NOTIFY_IN_PROGRESS	-106	/* Already awaiting a notification */
+#define SEND_KERNEL_REFUSED	-107	/* Message to the kernel refused */
+#define SEND_INTERRUPTED	-108	/* Software interrupt during send */
+#define SEND_MSG_TOO_LARGE	-109	/* Message specified was too large */
+#define SEND_MSG_TOO_SMALL	-110	/* Data specified exceeds msg size */
+/*	SEND_MSG_SIZE_CHANGE	-111	   Msg size changed during copy */
+#define SEND_ERRORS_END		-111
+
+#define msg_return_send(x)	((x) < SEND_ERRORS_START && (x) > SEND_ERRORS_END)
+
+#define RCV_SUCCESS		0
+
+#define RCV_ERRORS_START	-200
+#define RCV_INVALID_MEMORY	-201
+#define RCV_INVALID_PORT	-202
+#define RCV_TIMED_OUT		-203
+#define RCV_TOO_LARGE		-204	/* Msg structure too small for data */
+#define RCV_NOT_ENOUGH_MEMORY	-205	/* Can't find space for OOL data */
+#define RCV_ONLY_SENDER		-206	/* Receiver is only sender */
+#define RCV_INTERRUPTED		-207
+#define RCV_PORT_CHANGE		-208	/* Port was put in a set */
+#define RCV_ERRORS_END		-209
+
+#define msg_return_rcv(x)	((x) < RCV_ERRORS_START && (x) > RCV_ERRORS_END)
+
+#define RPC_SUCCESS		0
+
+/*
+ *	The IPC primitive functions themselves
+ */
+
+msg_return_t	msg_send(
+#if	defined(c_plusplus) || defined(__STDC__)
+	msg_header_t	*header,
+	msg_option_t	option,
+	msg_timeout_t	timeout);
+#else	/* c_plusplus || __STDC__ */
+#if	LINTLIBRARY
+			header, option, timeout)
+	msg_header_t	*header;
+	msg_option_t	option;
+	msg_timeout_t	timeout;
+	{ return(SEND_SUCCESS); }
+#else	/* LINTLIBRARY */
+		);
+#endif	/* LINTLIBRARY */
+#endif	/* c_plusplus || __STDC__ */
+
+msg_return_t	msg_receive(
+#if	defined(c_plusplus) || defined(__STDC__)
+	msg_header_t	*header,
+	msg_option_t	option,
+	msg_timeout_t	timeout);
+#else	/* c_plusplus || __STDC__ */
+#if	LINTLIBRARY
+			header, option, timeout)
+	msg_header_t	*header;
+	msg_option_t	option;
+	msg_timeout_t	timeout;
+	{ return(RCV_SUCCESS); }
+#else	/* LINTLIBRARY */
+		);
+#endif	/* LINTLIBRARY */
+#endif	/* c_plusplus || __STDC__ */
+
+msg_return_t	msg_rpc(
+#if	defined(c_plusplus) || defined(__STDC__)
+	msg_header_t	*header,	/* in/out */
+	msg_option_t	option,
+	msg_size_t	rcv_size,
+	msg_timeout_t	send_timeout,
+	msg_timeout_t	rcv_timeout);
+#else	/* c_plusplus || __STDC__ */
+#if	LINTLIBRARY
+			header, option, rcv_size,
+			send_timeout, rcv_timeout)
+	msg_header_t	*header;	/* in/out */
+	msg_option_t	option;
+	msg_size_t	rcv_size;
+	msg_timeout_t	send_timeout;
+	msg_timeout_t	rcv_timeout;
+	{ return(RPC_SUCCESS); }
+#else	/* LINTLIBRARY */
+		);
+#endif	/* LINTLIBRARY */
+#endif	/* c_plusplus || __STDC__ */
+
+msg_return_t	msg_send_trap(
+#if	defined(c_plusplus) || defined(__STDC__)
+	msg_header_t	*header,
+	msg_option_t	option,
+	msg_size_t	send_size,
+	msg_timeout_t	timeout);
+#else	/* c_plusplus || __STDC__ */
+#if	LINTLIBRARY
+			header, option, send_size, timeout)
+	msg_header_t	*header;
+	msg_option_t	option;
+	msg_size_t	send_size;
+	msg_timeout_t	timeout;
+	{ return(SEND_SUCCESS); }
+#else	/* LINTLIBRARY */
+		);
+#endif	/* LINTLIBRARY */
+#endif	/* c_plusplus || __STDC__ */
+
+msg_return_t	msg_receive_trap(
+#if	defined(c_plusplus) || defined(__STDC__)
+	msg_header_t	*header,
+	msg_option_t	option,
+	msg_size_t	rcv_size,
+	port_name_t	rcv_name,
+	msg_timeout_t	timeout);
+#else	/* c_plusplus || __STDC__ */
+#if	LINTLIBRARY
+			header, option, rcv_size, rcv_name, timeout)
+	msg_header_t	*header;
+	msg_option_t	option;
+	msg_size_t	rcv_size;
+	port_name_t	rcv_name;
+	msg_timeout_t	timeout;
+	{ return(RCV_SUCCESS); }
+#else	/* LINTLIBRARY */
+		);
+#endif	/* LINTLIBRARY */
+#endif	/* c_plusplus || __STDC__ */
+
+msg_return_t	msg_rpc_trap(
+#if	defined(c_plusplus) || defined(__STDC__)
+	msg_header_t	*header,	/* in/out */
+	msg_option_t	option,
+	msg_size_t	send_size,
+	msg_size_t	rcv_size,
+	msg_timeout_t	send_timeout,
+	msg_timeout_t	rcv_timeout);
+#else	/* c_plusplus || __STDC__ */
+#if	LINTLIBRARY
+			header, option, send_size, rcv_size,
+			send_timeout, rcv_timeout)
+	msg_header_t	*header;	/* in/out */
+	msg_option_t	option;
+	msg_size_t	send_size;
+	msg_size_t	rcv_size;
+	msg_timeout_t	send_timeout;
+	msg_timeout_t	rcv_timeout;
+	{ return(RPC_SUCCESS); }
+#else	/* LINTLIBRARY */
+		);
+#endif	/* LINTLIBRARY */
+#endif	/* c_plusplus || __STDC__ */
+
+#endif	/* MACH_IPC_COMPAT */
+
+#endif	/* _MACH_MESSAGE_H_ */