/*
- * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
*
- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License"). You may not use this file except in compliance with the
- * License. Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
*
- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
- * License for the specific language governing rights and limitations
- * under the License.
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
*
- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
*/
/*
* @OSF_COPYRIGHT@
* any improvements or extensions that they make and grant Carnegie Mellon
* the rights to redistribute these changes.
*/
+/*
+ * NOTICE: This file was modified by McAfee Research in 2004 to introduce
+ * support for mandatory and extensible security protections. This notice
+ * is included in support of clause 2.2 (b) of the Apple Public License,
+ * Version 2.0.
+ * Copyright (c) 2005-2006 SPARTA, Inc.
+ */
/*
*/
/*
#include <ipc/ipc_pset.h>
#include <ipc/ipc_right.h>
#include <ipc/ipc_kmsg.h>
+#include <ipc/ipc_labelh.h>
#include <kern/misc_protos.h>
+#include <security/mac_mach_internal.h>
+
+#include <mach/security_server.h>
/*
* Forward declarations
* Routine: mach_port_names_helper
* Purpose:
* A helper function for mach_port_names.
+ *
+ * Conditions:
+ * Space containing entry is [at least] read-locked.
*/
void
{
ipc_entry_bits_t bits;
ipc_port_request_index_t request;
- mach_port_type_t type;
+ mach_port_type_t type = 0;
ipc_entry_num_t actual;
+ ipc_port_t port;
bits = entry->ie_bits;
request = entry->ie_request;
- if (bits & MACH_PORT_TYPE_SEND_RIGHTS) {
- ipc_port_t port;
- boolean_t died;
+ port = (ipc_port_t) entry->ie_object;
- port = (ipc_port_t) entry->ie_object;
- assert(port != IP_NULL);
+ if (bits & MACH_PORT_TYPE_RECEIVE) {
+ assert(IP_VALID(port));
- /*
- * The timestamp serializes mach_port_names
- * with ipc_port_destroy. If the port died,
- * but after mach_port_names started, pretend
- * that it isn't dead.
- */
+ if (request != IE_REQ_NONE) {
+ ip_lock(port);
+ assert(ip_active(port));
+ type |= ipc_port_request_type(port, name, request);
+ ip_unlock(port);
+ }
- ip_lock(port);
- died = (!ip_active(port) &&
- IP_TIMESTAMP_ORDER(port->ip_timestamp, timestamp));
- ip_unlock(port);
+ } else if (bits & MACH_PORT_TYPE_SEND_RIGHTS) {
+ mach_port_type_t reqtype;
- if (died) {
- /* pretend this is a dead-name entry */
+ assert(IP_VALID(port));
+ ip_lock(port);
+ reqtype = (request != IE_REQ_NONE) ?
+ ipc_port_request_type(port, name, request) : 0;
+
+ /*
+ * If the port is alive, or was alive when the mach_port_names
+ * started, then return that fact. Otherwise, pretend we found
+ * a dead name entry.
+ */
+ if (ip_active(port) || IP_TIMESTAMP_ORDER(timestamp, port->ip_timestamp)) {
+ type |= reqtype;
+ } else {
bits &= ~(IE_BITS_TYPE_MASK);
bits |= MACH_PORT_TYPE_DEAD_NAME;
- if (request != 0)
+ /* account for additional reference for dead-name notification */
+ if (reqtype != 0)
bits++;
- request = 0;
}
+ ip_unlock(port);
}
- type = IE_BITS_TYPE(bits);
- if (request != 0)
- type |= MACH_PORT_TYPE_DNREQUEST;
+ type |= IE_BITS_TYPE(bits);
actual = *actualp;
names[actual] = name;
kr = ipc_right_info(space, name, entry, typep, &urefs);
if (kr == KERN_SUCCESS)
is_write_unlock(space);
+#if 1
+ /* JMM - workaround rdar://problem/9121297 (CF being too picky on these bits). */
+ *typep &= ~(MACH_PORT_TYPE_SPREQUEST | MACH_PORT_TYPE_SPREQUEST_DELAYED);
+#endif
+
/* space is unlocked */
return kr;
}
}
if (qosp->prealloc) {
- mach_msg_size_t size = qosp->len + MAX_TRAILER_SIZE;
- if (right != MACH_PORT_RIGHT_RECEIVE)
- return (KERN_INVALID_VALUE);
- kmsg = (ipc_kmsg_t)ipc_kmsg_alloc(size);
- if (kmsg == IKM_NULL)
- return (KERN_RESOURCE_SHORTAGE);
+ if (qosp->len > MACH_MSG_SIZE_MAX - MAX_TRAILER_SIZE) {
+ return KERN_RESOURCE_SHORTAGE;
+ } else {
+ mach_msg_size_t size = qosp->len + MAX_TRAILER_SIZE;
+
+ if (right != MACH_PORT_RIGHT_RECEIVE)
+ return (KERN_INVALID_VALUE);
+
+ kmsg = (ipc_kmsg_t)ipc_kmsg_prealloc(size);
+ if (kmsg == IKM_NULL)
+ return (KERN_RESOURCE_SHORTAGE);
+ }
}
switch (right) {
return KERN_SUCCESS;
}
+/*
+ * Routine: mach_port_get_context [kernel call]
+ * Purpose:
+ * Returns a receive right's context pointer.
+ * Conditions:
+ * Nothing locked.
+ * Returns:
+ * KERN_SUCCESS Set context pointer.
+ * KERN_INVALID_TASK The space is null.
+ * KERN_INVALID_TASK The space is dead.
+ * KERN_INVALID_NAME The name doesn't denote a right.
+ * KERN_INVALID_RIGHT Name doesn't denote receive rights.
+ */
+
+kern_return_t
+mach_port_get_context(
+ ipc_space_t space,
+ mach_port_name_t name,
+ mach_vm_address_t *context)
+{
+ ipc_port_t port;
+ kern_return_t kr;
+
+ if (space == IS_NULL)
+ return KERN_INVALID_TASK;
+
+ if (!MACH_PORT_VALID(name))
+ return KERN_INVALID_RIGHT;
+
+ kr = ipc_port_translate_receive(space, name, &port);
+ if (kr != KERN_SUCCESS)
+ return kr;
+
+ /* port is locked and active */
+ *context = port->ip_context;
+
+ ip_unlock(port);
+ return KERN_SUCCESS;
+}
+
+
+/*
+ * Routine: mach_port_set_context [kernel call]
+ * Purpose:
+ * Changes a receive right's context pointer.
+ * Conditions:
+ * Nothing locked.
+ * Returns:
+ * KERN_SUCCESS Set context pointer.
+ * KERN_INVALID_TASK The space is null.
+ * KERN_INVALID_TASK The space is dead.
+ * KERN_INVALID_NAME The name doesn't denote a right.
+ * KERN_INVALID_RIGHT Name doesn't denote receive rights.
+ */
+
+kern_return_t
+mach_port_set_context(
+ ipc_space_t space,
+ mach_port_name_t name,
+ mach_vm_address_t context)
+{
+ ipc_port_t port;
+ kern_return_t kr;
+
+ if (space == IS_NULL)
+ return KERN_INVALID_TASK;
+
+ if (!MACH_PORT_VALID(name))
+ return KERN_INVALID_RIGHT;
+
+ kr = ipc_port_translate_receive(space, name, &port);
+ if (kr != KERN_SUCCESS)
+ return kr;
+
+ /* port is locked and active */
+ port->ip_context = context;
+
+ ip_unlock(port);
+ return KERN_SUCCESS;
+}
+
+
/*
* Routine: mach_port_gst_helper
* Purpose:
/* the port set must be active */
names = (mach_port_name_t *) addr;
- maxnames = size / sizeof(mach_port_name_t);
+ maxnames = (ipc_entry_num_t)(size / sizeof(mach_port_name_t));
actual = 0;
table = space->is_table;
break;
}
+ case MACH_NOTIFY_SEND_POSSIBLE:
+
+ if (!MACH_PORT_VALID(name)) {
+ return KERN_INVALID_ARGUMENT;
+ }
+
+ kr = ipc_right_request_alloc(space, name, sync != 0,
+ TRUE, notify, previousp);
+ if (kr != KERN_SUCCESS)
+ return kr;
+ break;
+
case MACH_NOTIFY_DEAD_NAME:
if (!MACH_PORT_VALID(name)) {
return KERN_INVALID_ARGUMENT;
}
- kr = ipc_right_dnrequest(space, name, sync != 0,
- notify, previousp);
+ kr = ipc_right_request_alloc(space, name, sync != 0,
+ FALSE, notify, previousp);
if (kr != KERN_SUCCESS)
return kr;
break;
return kr;
/* port is locked and active */
- table = port->ip_dnrequests;
+ table = port->ip_requests;
if (table == IPR_NULL)
*(int *)info = 0;
else
return kr;
/* port is locked and active */
- kr = ipc_port_dngrow(port, *(int *)info);
+ kr = ipc_port_request_grow(port, *(int *)info);
if (kr != KERN_SUCCESS)
return kr;
break;
kern_return_t kr;
is_write_lock(space);
+
+ if (!space->is_active) {
+ is_write_unlock(space);
+ return KERN_INVALID_TASK;
+ }
+
kr = ipc_entry_grow_table(space, table_entries);
if (kr == KERN_SUCCESS)
is_write_unlock(space);
return kr;
}
+/*
+ * Get a (new) label handle representing the given port's port label.
+ */
+#if CONFIG_MACF_MACH
+kern_return_t
+mach_get_label(
+ ipc_space_t space,
+ mach_port_name_t name,
+ mach_port_name_t *outlabel)
+{
+ ipc_entry_t entry;
+ ipc_port_t port;
+ struct label outl;
+ kern_return_t kr;
+ int dead;
+
+ if (!MACH_PORT_VALID(name))
+ return KERN_INVALID_NAME;
+
+ /* Lookup the port name in the task's space. */
+ kr = ipc_right_lookup_write(space, name, &entry);
+ if (kr != KERN_SUCCESS)
+ return kr;
+
+ port = (ipc_port_t) entry->ie_object;
+ dead = ipc_right_check(space, port, name, entry);
+ if (dead) {
+ is_write_unlock(space);
+ return KERN_INVALID_RIGHT;
+ }
+ /* port is now locked */
+
+ is_write_unlock(space);
+ /* Make sure we are not dealing with a label handle. */
+ if (ip_kotype(port) == IKOT_LABELH) {
+ /* already is a label handle! */
+ ip_unlock(port);
+ return KERN_INVALID_ARGUMENT;
+ }
+
+ /* Copy the port label and stash it in a new label handle. */
+ mac_port_label_init(&outl);
+ mac_port_label_copy(&port->ip_label, &outl);
+ kr = labelh_new_user(space, &outl, outlabel);
+ ip_unlock(port);
+
+ return KERN_SUCCESS;
+}
+#else
+kern_return_t
+mach_get_label(
+ __unused ipc_space_t space,
+ __unused mach_port_name_t name,
+ __unused mach_port_name_t *outlabel)
+{
+ return KERN_INVALID_ARGUMENT;
+}
+#endif
+
+/*
+ * also works on label handles
+ */
+#if CONFIG_MACF_MACH
+kern_return_t
+mach_get_label_text(
+ ipc_space_t space,
+ mach_port_name_t name,
+ labelstr_t policies,
+ labelstr_t outlabel)
+{
+ ipc_entry_t entry;
+ kern_return_t kr;
+ struct label *l;
+ int dead;
+
+ if (space == IS_NULL || space->is_task == NULL)
+ return KERN_INVALID_TASK;
+
+ if (!MACH_PORT_VALID(name))
+ return KERN_INVALID_NAME;
+
+ kr = ipc_right_lookup_write(space, name, &entry);
+ if (kr != KERN_SUCCESS)
+ return kr;
+
+ dead = ipc_right_check(space, (ipc_port_t) entry->ie_object, name,
+ entry);
+ if (dead) {
+ is_write_unlock(space);
+ return KERN_INVALID_RIGHT;
+ }
+ /* object (port) is now locked */
+
+ is_write_unlock (space);
+ l = io_getlabel(entry->ie_object);
+
+ mac_port_label_externalize(l, policies, outlabel, 512, 0);
+
+ io_unlocklabel(entry->ie_object);
+ io_unlock(entry->ie_object);
+ return KERN_SUCCESS;
+}
+#else
+kern_return_t
+mach_get_label_text(
+ __unused ipc_space_t space,
+ __unused mach_port_name_t name,
+ __unused labelstr_t policies,
+ __unused labelstr_t outlabel)
+{
+ return KERN_INVALID_ARGUMENT;
+}
+#endif
+
+
+#if CONFIG_MACF_MACH
+kern_return_t
+mach_set_port_label(
+ ipc_space_t space,
+ mach_port_name_t name,
+ labelstr_t labelstr)
+{
+ ipc_entry_t entry;
+ kern_return_t kr;
+ struct label inl;
+ ipc_port_t port;
+ int rc;
+
+ if (space == IS_NULL || space->is_task == NULL)
+ return KERN_INVALID_TASK;
+
+ if (!MACH_PORT_VALID(name))
+ return KERN_INVALID_NAME;
+
+ mac_port_label_init(&inl);
+ rc = mac_port_label_internalize(&inl, labelstr);
+ if (rc)
+ return KERN_INVALID_ARGUMENT;
+
+ kr = ipc_right_lookup_write(space, name, &entry);
+ if (kr != KERN_SUCCESS)
+ return kr;
+
+ if (io_otype(entMACry->ie_object) != IOT_PORT) {
+ is_write_unlock(space);
+ return KERN_INVALID_RIGHT;
+ }
+
+ port = (ipc_port_t) entry->ie_object;
+ ip_lock(port);
+
+ tasklabel_lock(space->is_task);
+ rc = mac_port_check_label_update(&space->is_task->maclabel,
+ &port->ip_label, &inl);
+ tasklabel_unlock(space->is_task);
+ if (rc)
+ kr = KERN_NO_ACCESS;
+ else
+ mac_port_label_copy(&inl, &port->ip_label);
+
+ ip_unlock(port);
+ is_write_unlock(space);
+ return kr;
+}
+#else
+kern_return_t
+mach_set_port_label(
+ ipc_space_t space __unused,
+ mach_port_name_t name __unused,
+ labelstr_t labelstr __unused)
+{
+ return KERN_INVALID_ARGUMENT;
+}
+#endif
projects / apple / xnu.git / blobdiff