mac_pipe.c revision 104517
1100894Srwatson/*- 2100894Srwatson * Copyright (c) 1999, 2000, 2001, 2002 Robert N. M. Watson 3100894Srwatson * Copyright (c) 2001 Ilmar S. Habibulin 4100894Srwatson * Copyright (c) 2001, 2002 Networks Associates Technology, Inc. 5100894Srwatson * All rights reserved. 6100894Srwatson * 7100894Srwatson * This software was developed by Robert Watson and Ilmar Habibulin for the 8100894Srwatson * TrustedBSD Project. 9100894Srwatson * 10100894Srwatson * This software was developed for the FreeBSD Project in part by NAI Labs, 11100894Srwatson * the Security Research Division of Network Associates, Inc. under 12100894Srwatson * DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA 13100894Srwatson * CHATS research program. 14100894Srwatson * 15100894Srwatson * Redistribution and use in source and binary forms, with or without 16100894Srwatson * modification, are permitted provided that the following conditions 17100894Srwatson * are met: 18100894Srwatson * 1. Redistributions of source code must retain the above copyright 19100894Srwatson * notice, this list of conditions and the following disclaimer. 20100894Srwatson * 2. Redistributions in binary form must reproduce the above copyright 21100894Srwatson * notice, this list of conditions and the following disclaimer in the 22100894Srwatson * documentation and/or other materials provided with the distribution. 23100894Srwatson * 3. The names of the authors may not be used to endorse or promote 24100894Srwatson * products derived from this software without specific prior written 25100894Srwatson * permission. 26100894Srwatson * 27100894Srwatson * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 28100894Srwatson * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 29100894Srwatson * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 30100894Srwatson * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 31100894Srwatson * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 32100894Srwatson * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 33100894Srwatson * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 34100894Srwatson * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 35100894Srwatson * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 36100894Srwatson * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 37100894Srwatson * SUCH DAMAGE. 38100894Srwatson * 39100894Srwatson * $FreeBSD: head/sys/security/mac/mac_pipe.c 104517 2002-10-05 16:30:53Z rwatson $ 40100894Srwatson */ 41100894Srwatson/* 42100894Srwatson * Developed by the TrustedBSD Project. 43100894Srwatson * 44100894Srwatson * Framework for extensible kernel access control. Kernel and userland 45100894Srwatson * interface to the framework, policy registration and composition. 46100894Srwatson */ 47100894Srwatson 48100894Srwatson#include "opt_mac.h" 49104300Sphk#include "opt_devfs.h" 50101173Srwatson 51100894Srwatson#include <sys/param.h> 52100979Srwatson#include <sys/extattr.h> 53100979Srwatson#include <sys/kernel.h> 54100979Srwatson#include <sys/lock.h> 55102949Sbde#include <sys/malloc.h> 56100979Srwatson#include <sys/mutex.h> 57100979Srwatson#include <sys/mac.h> 58101712Srwatson#include <sys/module.h> 59100979Srwatson#include <sys/proc.h> 60100979Srwatson#include <sys/systm.h> 61100894Srwatson#include <sys/sysproto.h> 62100894Srwatson#include <sys/sysent.h> 63100979Srwatson#include <sys/vnode.h> 64100979Srwatson#include <sys/mount.h> 65100979Srwatson#include <sys/file.h> 66100979Srwatson#include <sys/namei.h> 67100979Srwatson#include <sys/socket.h> 68100979Srwatson#include <sys/pipe.h> 69100979Srwatson#include <sys/socketvar.h> 70100979Srwatson#include <sys/sysctl.h> 71100894Srwatson 72100979Srwatson#include <vm/vm.h> 73100979Srwatson#include <vm/pmap.h> 74100979Srwatson#include <vm/vm_map.h> 75100979Srwatson#include <vm/vm_object.h> 76100979Srwatson 77100979Srwatson#include <sys/mac_policy.h> 78100979Srwatson 79100979Srwatson#include <fs/devfs/devfs.h> 80100979Srwatson 81100979Srwatson#include <net/bpfdesc.h> 82100979Srwatson#include <net/if.h> 83100979Srwatson#include <net/if_var.h> 84100979Srwatson 85100979Srwatson#include <netinet/in.h> 86100979Srwatson#include <netinet/ip_var.h> 87100979Srwatson 88100979Srwatson#ifdef MAC 89100979Srwatson 90101712Srwatson/* 91101712Srwatson * Declare that the kernel provides MAC support, version 1. This permits 92101712Srwatson * modules to refuse to be loaded if the necessary support isn't present, 93101712Srwatson * even if it's pre-boot. 94101712Srwatson */ 95101712SrwatsonMODULE_VERSION(kernel_mac_support, 1); 96101712Srwatson 97100979SrwatsonSYSCTL_DECL(_security); 98100979Srwatson 99100979SrwatsonSYSCTL_NODE(_security, OID_AUTO, mac, CTLFLAG_RW, 0, 100100979Srwatson "TrustedBSD MAC policy controls"); 101104517Srwatson 102100979Srwatson#ifndef MAC_MAX_POLICIES 103100979Srwatson#define MAC_MAX_POLICIES 8 104100979Srwatson#endif 105100979Srwatson#if MAC_MAX_POLICIES > 32 106100979Srwatson#error "MAC_MAX_POLICIES too large" 107100979Srwatson#endif 108100979Srwatsonstatic unsigned int mac_max_policies = MAC_MAX_POLICIES; 109100979Srwatsonstatic unsigned int mac_policy_offsets_free = (1 << MAC_MAX_POLICIES) - 1; 110100979SrwatsonSYSCTL_UINT(_security_mac, OID_AUTO, max_policies, CTLFLAG_RD, 111100979Srwatson &mac_max_policies, 0, ""); 112100979Srwatson 113100979Srwatsonstatic int mac_late = 0; 114100979Srwatson 115100979Srwatsonstatic int mac_enforce_fs = 1; 116100979SrwatsonSYSCTL_INT(_security_mac, OID_AUTO, enforce_fs, CTLFLAG_RW, 117100979Srwatson &mac_enforce_fs, 0, "Enforce MAC policy on file system objects"); 118100979SrwatsonTUNABLE_INT("security.mac.enforce_fs", &mac_enforce_fs); 119100979Srwatson 120100979Srwatsonstatic int mac_enforce_network = 1; 121100979SrwatsonSYSCTL_INT(_security_mac, OID_AUTO, enforce_network, CTLFLAG_RW, 122100979Srwatson &mac_enforce_network, 0, "Enforce MAC policy on network packets"); 123100979SrwatsonTUNABLE_INT("security.mac.enforce_network", &mac_enforce_network); 124100979Srwatson 125103513Srwatsonstatic int mac_enforce_pipe = 1; 126103513SrwatsonSYSCTL_INT(_security_mac, OID_AUTO, enforce_pipe, CTLFLAG_RW, 127103513Srwatson &mac_enforce_pipe, 0, "Enforce MAC policy on pipe operations"); 128104236SrwatsonTUNABLE_INT("security.mac.enforce_pipe", &mac_enforce_pipe); 129103513Srwatson 130100979Srwatsonstatic int mac_enforce_process = 1; 131100979SrwatsonSYSCTL_INT(_security_mac, OID_AUTO, enforce_process, CTLFLAG_RW, 132100979Srwatson &mac_enforce_process, 0, "Enforce MAC policy on inter-process operations"); 133100979SrwatsonTUNABLE_INT("security.mac.enforce_process", &mac_enforce_process); 134100979Srwatson 135100979Srwatsonstatic int mac_enforce_socket = 1; 136100979SrwatsonSYSCTL_INT(_security_mac, OID_AUTO, enforce_socket, CTLFLAG_RW, 137100979Srwatson &mac_enforce_socket, 0, "Enforce MAC policy on socket operations"); 138100979SrwatsonTUNABLE_INT("security.mac.enforce_socket", &mac_enforce_socket); 139100979Srwatson 140103514Srwatsonstatic int mac_enforce_vm = 1; 141103514SrwatsonSYSCTL_INT(_security_mac, OID_AUTO, enforce_vm, CTLFLAG_RW, 142103514Srwatson &mac_enforce_vm, 0, "Enforce MAC policy on vm operations"); 143104236SrwatsonTUNABLE_INT("security.mac.enforce_vm", &mac_enforce_vm); 144103514Srwatson 145100979Srwatsonstatic int mac_label_size = sizeof(struct mac); 146100979SrwatsonSYSCTL_INT(_security_mac, OID_AUTO, label_size, CTLFLAG_RD, 147100979Srwatson &mac_label_size, 0, "Pre-compiled MAC label size"); 148100979Srwatson 149100979Srwatsonstatic int mac_cache_fslabel_in_vnode = 1; 150100979SrwatsonSYSCTL_INT(_security_mac, OID_AUTO, cache_fslabel_in_vnode, CTLFLAG_RW, 151100979Srwatson &mac_cache_fslabel_in_vnode, 0, "Cache mount fslabel in vnode"); 152100979SrwatsonTUNABLE_INT("security.mac.cache_fslabel_in_vnode", 153100979Srwatson &mac_cache_fslabel_in_vnode); 154100979Srwatson 155100979Srwatsonstatic int mac_vnode_label_cache_hits = 0; 156100979SrwatsonSYSCTL_INT(_security_mac, OID_AUTO, vnode_label_cache_hits, CTLFLAG_RD, 157100979Srwatson &mac_vnode_label_cache_hits, 0, "Cache hits on vnode labels"); 158100979Srwatsonstatic int mac_vnode_label_cache_misses = 0; 159100979SrwatsonSYSCTL_INT(_security_mac, OID_AUTO, vnode_label_cache_misses, CTLFLAG_RD, 160100979Srwatson &mac_vnode_label_cache_misses, 0, "Cache misses on vnode labels"); 161103136Srwatson 162103136Srwatsonstatic int mac_mmap_revocation = 1; 163103136SrwatsonSYSCTL_INT(_security_mac, OID_AUTO, mmap_revocation, CTLFLAG_RW, 164103136Srwatson &mac_mmap_revocation, 0, "Revoke mmap access to files on subject " 165103136Srwatson "relabel"); 166101892Srwatsonstatic int mac_mmap_revocation_via_cow = 0; 167100979SrwatsonSYSCTL_INT(_security_mac, OID_AUTO, mmap_revocation_via_cow, CTLFLAG_RW, 168100979Srwatson &mac_mmap_revocation_via_cow, 0, "Revoke mmap access to files via " 169100979Srwatson "copy-on-write semantics, or by removing all write access"); 170100979Srwatson 171101988Srwatson#ifdef MAC_DEBUG 172104268SrwatsonSYSCTL_NODE(_security_mac, OID_AUTO, debug, CTLFLAG_RW, 0, 173104268Srwatson "TrustedBSD MAC debug info"); 174104268Srwatson 175104268Srwatsonstatic int mac_debug_label_fallback = 0; 176104268SrwatsonSYSCTL_INT(_security_mac_debug, OID_AUTO, label_fallback, CTLFLAG_RW, 177104268Srwatson &mac_debug_label_fallback, 0, "Filesystems should fall back to fs label" 178104268Srwatson "when label is corrupted."); 179104268SrwatsonTUNABLE_INT("security.mac.debug_label_fallback", 180104268Srwatson &mac_debug_label_fallback); 181104268Srwatson 182104517SrwatsonSYSCTL_NODE(_security_mac_debug, OID_AUTO, counters, CTLFLAG_RW, 0, 183104517Srwatson "TrustedBSD MAC object counters"); 184104517Srwatson 185100979Srwatsonstatic unsigned int nmacmbufs, nmaccreds, nmacifnets, nmacbpfdescs, 186100979Srwatson nmacsockets, nmacmounts, nmactemp, nmacvnodes, nmacdevfsdirents, 187100979Srwatson nmacipqs, nmacpipes; 188104517Srwatson 189104517SrwatsonSYSCTL_UINT(_security_mac_debug_counters, OID_AUTO, mbufs, CTLFLAG_RD, 190100979Srwatson &nmacmbufs, 0, "number of mbufs in use"); 191104517SrwatsonSYSCTL_UINT(_security_mac_debug_counters, OID_AUTO, creds, CTLFLAG_RD, 192100979Srwatson &nmaccreds, 0, "number of ucreds in use"); 193104517SrwatsonSYSCTL_UINT(_security_mac_debug_counters, OID_AUTO, ifnets, CTLFLAG_RD, 194100979Srwatson &nmacifnets, 0, "number of ifnets in use"); 195104517SrwatsonSYSCTL_UINT(_security_mac_debug_counters, OID_AUTO, ipqs, CTLFLAG_RD, 196100979Srwatson &nmacipqs, 0, "number of ipqs in use"); 197104517SrwatsonSYSCTL_UINT(_security_mac_debug_counters, OID_AUTO, bpfdescs, CTLFLAG_RD, 198100979Srwatson &nmacbpfdescs, 0, "number of bpfdescs in use"); 199104517SrwatsonSYSCTL_UINT(_security_mac_debug_counters, OID_AUTO, sockets, CTLFLAG_RD, 200100979Srwatson &nmacsockets, 0, "number of sockets in use"); 201104517SrwatsonSYSCTL_UINT(_security_mac_debug_counters, OID_AUTO, pipes, CTLFLAG_RD, 202100979Srwatson &nmacpipes, 0, "number of pipes in use"); 203104517SrwatsonSYSCTL_UINT(_security_mac_debug_counters, OID_AUTO, mounts, CTLFLAG_RD, 204100979Srwatson &nmacmounts, 0, "number of mounts in use"); 205104517SrwatsonSYSCTL_UINT(_security_mac_debug_counters, OID_AUTO, temp, CTLFLAG_RD, 206100979Srwatson &nmactemp, 0, "number of temporary labels in use"); 207104517SrwatsonSYSCTL_UINT(_security_mac_debug_counters, OID_AUTO, vnodes, CTLFLAG_RD, 208100979Srwatson &nmacvnodes, 0, "number of vnodes in use"); 209104517SrwatsonSYSCTL_UINT(_security_mac_debug_counters, OID_AUTO, devfsdirents, CTLFLAG_RD, 210100979Srwatson &nmacdevfsdirents, 0, "number of devfs dirents inuse"); 211101988Srwatson#endif 212100979Srwatson 213100979Srwatsonstatic int error_select(int error1, int error2); 214100979Srwatsonstatic int mac_externalize(struct label *label, struct mac *mac); 215100979Srwatsonstatic int mac_policy_register(struct mac_policy_conf *mpc); 216100979Srwatsonstatic int mac_policy_unregister(struct mac_policy_conf *mpc); 217100979Srwatson 218100979Srwatsonstatic int mac_stdcreatevnode_ea(struct vnode *vp); 219100979Srwatsonstatic void mac_cred_mmapped_drop_perms(struct thread *td, 220100979Srwatson struct ucred *cred); 221100979Srwatsonstatic void mac_cred_mmapped_drop_perms_recurse(struct thread *td, 222100979Srwatson struct ucred *cred, struct vm_map *map); 223100979Srwatson 224100979SrwatsonMALLOC_DEFINE(M_MACOPVEC, "macopvec", "MAC policy operation vector"); 225100979SrwatsonMALLOC_DEFINE(M_MACPIPELABEL, "macpipelabel", "MAC labels for pipes"); 226100979Srwatson 227100979Srwatson/* 228100979Srwatson * mac_policy_list_lock protects the consistency of 'mac_policy_list', 229100979Srwatson * the linked list of attached policy modules. Read-only consumers of 230100979Srwatson * the list must acquire a shared lock for the duration of their use; 231100979Srwatson * writers must acquire an exclusive lock. Note that for compound 232100979Srwatson * operations, locks should be held for the entire compound operation, 233100979Srwatson * and that this is not yet done for relabel requests. 234100979Srwatson */ 235100979Srwatsonstatic struct mtx mac_policy_list_lock; 236100979Srwatsonstatic LIST_HEAD(, mac_policy_conf) mac_policy_list; 237100979Srwatsonstatic int mac_policy_list_busy; 238100979Srwatson#define MAC_POLICY_LIST_LOCKINIT() mtx_init(&mac_policy_list_lock, \ 239100979Srwatson "mac_policy_list_lock", NULL, MTX_DEF); 240100979Srwatson#define MAC_POLICY_LIST_LOCK() mtx_lock(&mac_policy_list_lock); 241100979Srwatson#define MAC_POLICY_LIST_UNLOCK() mtx_unlock(&mac_policy_list_lock); 242100979Srwatson 243100979Srwatson#define MAC_POLICY_LIST_BUSY() do { \ 244100979Srwatson MAC_POLICY_LIST_LOCK(); \ 245100979Srwatson mac_policy_list_busy++; \ 246100979Srwatson MAC_POLICY_LIST_UNLOCK(); \ 247100979Srwatson} while (0) 248100979Srwatson 249100979Srwatson#define MAC_POLICY_LIST_UNBUSY() do { \ 250100979Srwatson MAC_POLICY_LIST_LOCK(); \ 251100979Srwatson mac_policy_list_busy--; \ 252100979Srwatson if (mac_policy_list_busy < 0) \ 253100979Srwatson panic("Extra mac_policy_list_busy--"); \ 254100979Srwatson MAC_POLICY_LIST_UNLOCK(); \ 255100979Srwatson} while (0) 256100979Srwatson 257100979Srwatson/* 258100979Srwatson * MAC_CHECK performs the designated check by walking the policy 259100979Srwatson * module list and checking with each as to how it feels about the 260100979Srwatson * request. Note that it returns its value via 'error' in the scope 261100979Srwatson * of the caller. 262100979Srwatson */ 263100979Srwatson#define MAC_CHECK(check, args...) do { \ 264100979Srwatson struct mac_policy_conf *mpc; \ 265100979Srwatson \ 266100979Srwatson error = 0; \ 267100979Srwatson MAC_POLICY_LIST_BUSY(); \ 268100979Srwatson LIST_FOREACH(mpc, &mac_policy_list, mpc_list) { \ 269100979Srwatson if (mpc->mpc_ops->mpo_ ## check != NULL) \ 270100979Srwatson error = error_select( \ 271100979Srwatson mpc->mpc_ops->mpo_ ## check (args), \ 272100979Srwatson error); \ 273100979Srwatson } \ 274100979Srwatson MAC_POLICY_LIST_UNBUSY(); \ 275100979Srwatson} while (0) 276100979Srwatson 277100979Srwatson/* 278100979Srwatson * MAC_BOOLEAN performs the designated boolean composition by walking 279100979Srwatson * the module list, invoking each instance of the operation, and 280100979Srwatson * combining the results using the passed C operator. Note that it 281100979Srwatson * returns its value via 'result' in the scope of the caller, which 282100979Srwatson * should be initialized by the caller in a meaningful way to get 283100979Srwatson * a meaningful result. 284100979Srwatson */ 285100979Srwatson#define MAC_BOOLEAN(operation, composition, args...) do { \ 286100979Srwatson struct mac_policy_conf *mpc; \ 287100979Srwatson \ 288100979Srwatson MAC_POLICY_LIST_BUSY(); \ 289100979Srwatson LIST_FOREACH(mpc, &mac_policy_list, mpc_list) { \ 290100979Srwatson if (mpc->mpc_ops->mpo_ ## operation != NULL) \ 291100979Srwatson result = result composition \ 292100979Srwatson mpc->mpc_ops->mpo_ ## operation (args); \ 293100979Srwatson } \ 294100979Srwatson MAC_POLICY_LIST_UNBUSY(); \ 295100979Srwatson} while (0) 296100979Srwatson 297100979Srwatson/* 298100979Srwatson * MAC_PERFORM performs the designated operation by walking the policy 299100979Srwatson * module list and invoking that operation for each policy. 300100979Srwatson */ 301100979Srwatson#define MAC_PERFORM(operation, args...) do { \ 302100979Srwatson struct mac_policy_conf *mpc; \ 303100979Srwatson \ 304100979Srwatson MAC_POLICY_LIST_BUSY(); \ 305100979Srwatson LIST_FOREACH(mpc, &mac_policy_list, mpc_list) { \ 306100979Srwatson if (mpc->mpc_ops->mpo_ ## operation != NULL) \ 307100979Srwatson mpc->mpc_ops->mpo_ ## operation (args); \ 308100979Srwatson } \ 309100979Srwatson MAC_POLICY_LIST_UNBUSY(); \ 310100979Srwatson} while (0) 311100979Srwatson 312100979Srwatson/* 313100979Srwatson * Initialize the MAC subsystem, including appropriate SMP locks. 314100979Srwatson */ 315100979Srwatsonstatic void 316100979Srwatsonmac_init(void) 317100979Srwatson{ 318100979Srwatson 319100979Srwatson LIST_INIT(&mac_policy_list); 320100979Srwatson MAC_POLICY_LIST_LOCKINIT(); 321100979Srwatson} 322100979Srwatson 323100979Srwatson/* 324100979Srwatson * For the purposes of modules that want to know if they were loaded 325100979Srwatson * "early", set the mac_late flag once we've processed modules either 326100979Srwatson * linked into the kernel, or loaded before the kernel startup. 327100979Srwatson */ 328100979Srwatsonstatic void 329100979Srwatsonmac_late_init(void) 330100979Srwatson{ 331100979Srwatson 332100979Srwatson mac_late = 1; 333100979Srwatson} 334100979Srwatson 335100979Srwatson/* 336100979Srwatson * Allow MAC policy modules to register during boot, etc. 337100979Srwatson */ 338100894Srwatsonint 339100979Srwatsonmac_policy_modevent(module_t mod, int type, void *data) 340100979Srwatson{ 341100979Srwatson struct mac_policy_conf *mpc; 342100979Srwatson int error; 343100979Srwatson 344100979Srwatson error = 0; 345100979Srwatson mpc = (struct mac_policy_conf *) data; 346100979Srwatson 347100979Srwatson switch (type) { 348100979Srwatson case MOD_LOAD: 349100979Srwatson if (mpc->mpc_loadtime_flags & MPC_LOADTIME_FLAG_NOTLATE && 350100979Srwatson mac_late) { 351100979Srwatson printf("mac_policy_modevent: can't load %s policy " 352100979Srwatson "after booting\n", mpc->mpc_name); 353100979Srwatson error = EBUSY; 354100979Srwatson break; 355100979Srwatson } 356100979Srwatson error = mac_policy_register(mpc); 357100979Srwatson break; 358100979Srwatson case MOD_UNLOAD: 359100979Srwatson /* Don't unregister the module if it was never registered. */ 360100979Srwatson if ((mpc->mpc_runtime_flags & MPC_RUNTIME_FLAG_REGISTERED) 361100979Srwatson != 0) 362100979Srwatson error = mac_policy_unregister(mpc); 363100979Srwatson else 364100979Srwatson error = 0; 365100979Srwatson break; 366100979Srwatson default: 367100979Srwatson break; 368100979Srwatson } 369100979Srwatson 370100979Srwatson return (error); 371100979Srwatson} 372100979Srwatson 373100979Srwatsonstatic int 374100979Srwatsonmac_policy_register(struct mac_policy_conf *mpc) 375100979Srwatson{ 376100979Srwatson struct mac_policy_conf *tmpc; 377100979Srwatson struct mac_policy_op_entry *mpe; 378100979Srwatson int slot; 379100979Srwatson 380103570Srwatson MALLOC(mpc->mpc_ops, struct mac_policy_ops *, sizeof(*mpc->mpc_ops), 381103570Srwatson M_MACOPVEC, M_WAITOK | M_ZERO); 382100979Srwatson for (mpe = mpc->mpc_entries; mpe->mpe_constant != MAC_OP_LAST; mpe++) { 383100979Srwatson switch (mpe->mpe_constant) { 384100979Srwatson case MAC_OP_LAST: 385100979Srwatson /* 386100979Srwatson * Doesn't actually happen, but this allows checking 387100979Srwatson * that all enumerated values are handled. 388100979Srwatson */ 389100979Srwatson break; 390100979Srwatson case MAC_DESTROY: 391100979Srwatson mpc->mpc_ops->mpo_destroy = 392100979Srwatson mpe->mpe_function; 393100979Srwatson break; 394100979Srwatson case MAC_INIT: 395100979Srwatson mpc->mpc_ops->mpo_init = 396100979Srwatson mpe->mpe_function; 397100979Srwatson break; 398102123Srwatson case MAC_SYSCALL: 399102123Srwatson mpc->mpc_ops->mpo_syscall = 400102123Srwatson mpe->mpe_function; 401102123Srwatson break; 402104514Srwatson case MAC_INIT_BPFDESC_LABEL: 403104514Srwatson mpc->mpc_ops->mpo_init_bpfdesc_label = 404100979Srwatson mpe->mpe_function; 405100979Srwatson break; 406104514Srwatson case MAC_INIT_CRED_LABEL: 407104514Srwatson mpc->mpc_ops->mpo_init_cred_label = 408100979Srwatson mpe->mpe_function; 409100979Srwatson break; 410104514Srwatson case MAC_INIT_DEVFSDIRENT_LABEL: 411104514Srwatson mpc->mpc_ops->mpo_init_devfsdirent_label = 412100979Srwatson mpe->mpe_function; 413100979Srwatson break; 414104514Srwatson case MAC_INIT_IFNET_LABEL: 415104514Srwatson mpc->mpc_ops->mpo_init_ifnet_label = 416100979Srwatson mpe->mpe_function; 417100979Srwatson break; 418104514Srwatson case MAC_INIT_IPQ_LABEL: 419104514Srwatson mpc->mpc_ops->mpo_init_ipq_label = 420100979Srwatson mpe->mpe_function; 421100979Srwatson break; 422104514Srwatson case MAC_INIT_MBUF_LABEL: 423104514Srwatson mpc->mpc_ops->mpo_init_mbuf_label = 424100979Srwatson mpe->mpe_function; 425100979Srwatson break; 426104514Srwatson case MAC_INIT_MOUNT_LABEL: 427104514Srwatson mpc->mpc_ops->mpo_init_mount_label = 428100979Srwatson mpe->mpe_function; 429100979Srwatson break; 430104514Srwatson case MAC_INIT_MOUNT_FS_LABEL: 431104514Srwatson mpc->mpc_ops->mpo_init_mount_fs_label = 432100979Srwatson mpe->mpe_function; 433100979Srwatson break; 434104514Srwatson case MAC_INIT_PIPE_LABEL: 435104514Srwatson mpc->mpc_ops->mpo_init_pipe_label = 436100979Srwatson mpe->mpe_function; 437100979Srwatson break; 438104514Srwatson case MAC_INIT_SOCKET_LABEL: 439104514Srwatson mpc->mpc_ops->mpo_init_socket_label = 440100979Srwatson mpe->mpe_function; 441100979Srwatson break; 442104514Srwatson case MAC_INIT_SOCKET_PEER_LABEL: 443104514Srwatson mpc->mpc_ops->mpo_init_socket_peer_label = 444100979Srwatson mpe->mpe_function; 445100979Srwatson break; 446104514Srwatson case MAC_INIT_TEMP_LABEL: 447104514Srwatson mpc->mpc_ops->mpo_init_temp_label = 448100979Srwatson mpe->mpe_function; 449100979Srwatson break; 450104514Srwatson case MAC_INIT_VNODE_LABEL: 451104514Srwatson mpc->mpc_ops->mpo_init_vnode_label = 452100979Srwatson mpe->mpe_function; 453100979Srwatson break; 454104514Srwatson case MAC_DESTROY_BPFDESC_LABEL: 455104514Srwatson mpc->mpc_ops->mpo_destroy_bpfdesc_label = 456100979Srwatson mpe->mpe_function; 457100979Srwatson break; 458104514Srwatson case MAC_DESTROY_CRED_LABEL: 459104514Srwatson mpc->mpc_ops->mpo_destroy_cred_label = 460100979Srwatson mpe->mpe_function; 461100979Srwatson break; 462104514Srwatson case MAC_DESTROY_DEVFSDIRENT_LABEL: 463104514Srwatson mpc->mpc_ops->mpo_destroy_devfsdirent_label = 464100979Srwatson mpe->mpe_function; 465100979Srwatson break; 466104514Srwatson case MAC_DESTROY_IFNET_LABEL: 467104514Srwatson mpc->mpc_ops->mpo_destroy_ifnet_label = 468100979Srwatson mpe->mpe_function; 469100979Srwatson break; 470104514Srwatson case MAC_DESTROY_IPQ_LABEL: 471104514Srwatson mpc->mpc_ops->mpo_destroy_ipq_label = 472100979Srwatson mpe->mpe_function; 473100979Srwatson break; 474104514Srwatson case MAC_DESTROY_MBUF_LABEL: 475104514Srwatson mpc->mpc_ops->mpo_destroy_mbuf_label = 476100979Srwatson mpe->mpe_function; 477100979Srwatson break; 478104514Srwatson case MAC_DESTROY_MOUNT_LABEL: 479104514Srwatson mpc->mpc_ops->mpo_destroy_mount_label = 480100979Srwatson mpe->mpe_function; 481100979Srwatson break; 482104514Srwatson case MAC_DESTROY_MOUNT_FS_LABEL: 483104514Srwatson mpc->mpc_ops->mpo_destroy_mount_fs_label = 484100979Srwatson mpe->mpe_function; 485100979Srwatson break; 486104514Srwatson case MAC_DESTROY_PIPE_LABEL: 487104514Srwatson mpc->mpc_ops->mpo_destroy_pipe_label = 488100979Srwatson mpe->mpe_function; 489100979Srwatson break; 490104514Srwatson case MAC_DESTROY_SOCKET_LABEL: 491104514Srwatson mpc->mpc_ops->mpo_destroy_socket_label = 492104514Srwatson mpe->mpe_function; 493104514Srwatson break; 494104514Srwatson case MAC_DESTROY_SOCKET_PEER_LABEL: 495104514Srwatson mpc->mpc_ops->mpo_destroy_socket_peer_label = 496104514Srwatson mpe->mpe_function; 497104514Srwatson break; 498104514Srwatson case MAC_DESTROY_TEMP_LABEL: 499104514Srwatson mpc->mpc_ops->mpo_destroy_temp_label = 500104514Srwatson mpe->mpe_function; 501104514Srwatson break; 502104514Srwatson case MAC_DESTROY_VNODE_LABEL: 503104514Srwatson mpc->mpc_ops->mpo_destroy_vnode_label = 504104514Srwatson mpe->mpe_function; 505104514Srwatson break; 506100979Srwatson case MAC_EXTERNALIZE: 507100979Srwatson mpc->mpc_ops->mpo_externalize = 508100979Srwatson mpe->mpe_function; 509100979Srwatson break; 510100979Srwatson case MAC_INTERNALIZE: 511100979Srwatson mpc->mpc_ops->mpo_internalize = 512100979Srwatson mpe->mpe_function; 513100979Srwatson break; 514100979Srwatson case MAC_CREATE_DEVFS_DEVICE: 515100979Srwatson mpc->mpc_ops->mpo_create_devfs_device = 516100979Srwatson mpe->mpe_function; 517100979Srwatson break; 518100979Srwatson case MAC_CREATE_DEVFS_DIRECTORY: 519100979Srwatson mpc->mpc_ops->mpo_create_devfs_directory = 520100979Srwatson mpe->mpe_function; 521100979Srwatson break; 522100979Srwatson case MAC_CREATE_DEVFS_VNODE: 523100979Srwatson mpc->mpc_ops->mpo_create_devfs_vnode = 524100979Srwatson mpe->mpe_function; 525100979Srwatson break; 526100979Srwatson case MAC_STDCREATEVNODE_EA: 527100979Srwatson mpc->mpc_ops->mpo_stdcreatevnode_ea = 528100979Srwatson mpe->mpe_function; 529100979Srwatson break; 530100979Srwatson case MAC_CREATE_VNODE: 531100979Srwatson mpc->mpc_ops->mpo_create_vnode = 532100979Srwatson mpe->mpe_function; 533100979Srwatson break; 534100979Srwatson case MAC_CREATE_MOUNT: 535100979Srwatson mpc->mpc_ops->mpo_create_mount = 536100979Srwatson mpe->mpe_function; 537100979Srwatson break; 538100979Srwatson case MAC_CREATE_ROOT_MOUNT: 539100979Srwatson mpc->mpc_ops->mpo_create_root_mount = 540100979Srwatson mpe->mpe_function; 541100979Srwatson break; 542100979Srwatson case MAC_RELABEL_VNODE: 543100979Srwatson mpc->mpc_ops->mpo_relabel_vnode = 544100979Srwatson mpe->mpe_function; 545100979Srwatson break; 546100979Srwatson case MAC_UPDATE_DEVFSDIRENT: 547100979Srwatson mpc->mpc_ops->mpo_update_devfsdirent = 548100979Srwatson mpe->mpe_function; 549100979Srwatson break; 550100979Srwatson case MAC_UPDATE_PROCFSVNODE: 551100979Srwatson mpc->mpc_ops->mpo_update_procfsvnode = 552100979Srwatson mpe->mpe_function; 553100979Srwatson break; 554100979Srwatson case MAC_UPDATE_VNODE_FROM_EXTATTR: 555100979Srwatson mpc->mpc_ops->mpo_update_vnode_from_extattr = 556100979Srwatson mpe->mpe_function; 557100979Srwatson break; 558100979Srwatson case MAC_UPDATE_VNODE_FROM_EXTERNALIZED: 559100979Srwatson mpc->mpc_ops->mpo_update_vnode_from_externalized = 560100979Srwatson mpe->mpe_function; 561100979Srwatson break; 562100979Srwatson case MAC_UPDATE_VNODE_FROM_MOUNT: 563100979Srwatson mpc->mpc_ops->mpo_update_vnode_from_mount = 564100979Srwatson mpe->mpe_function; 565100979Srwatson break; 566100979Srwatson case MAC_CREATE_MBUF_FROM_SOCKET: 567100979Srwatson mpc->mpc_ops->mpo_create_mbuf_from_socket = 568100979Srwatson mpe->mpe_function; 569100979Srwatson break; 570100979Srwatson case MAC_CREATE_PIPE: 571100979Srwatson mpc->mpc_ops->mpo_create_pipe = 572100979Srwatson mpe->mpe_function; 573100979Srwatson break; 574100979Srwatson case MAC_CREATE_SOCKET: 575100979Srwatson mpc->mpc_ops->mpo_create_socket = 576100979Srwatson mpe->mpe_function; 577100979Srwatson break; 578100979Srwatson case MAC_CREATE_SOCKET_FROM_SOCKET: 579100979Srwatson mpc->mpc_ops->mpo_create_socket_from_socket = 580100979Srwatson mpe->mpe_function; 581100979Srwatson break; 582100979Srwatson case MAC_RELABEL_PIPE: 583100979Srwatson mpc->mpc_ops->mpo_relabel_pipe = 584100979Srwatson mpe->mpe_function; 585100979Srwatson break; 586100979Srwatson case MAC_RELABEL_SOCKET: 587100979Srwatson mpc->mpc_ops->mpo_relabel_socket = 588100979Srwatson mpe->mpe_function; 589100979Srwatson break; 590100979Srwatson case MAC_SET_SOCKET_PEER_FROM_MBUF: 591100979Srwatson mpc->mpc_ops->mpo_set_socket_peer_from_mbuf = 592100979Srwatson mpe->mpe_function; 593100979Srwatson break; 594100979Srwatson case MAC_SET_SOCKET_PEER_FROM_SOCKET: 595100979Srwatson mpc->mpc_ops->mpo_set_socket_peer_from_socket = 596100979Srwatson mpe->mpe_function; 597100979Srwatson break; 598100979Srwatson case MAC_CREATE_BPFDESC: 599100979Srwatson mpc->mpc_ops->mpo_create_bpfdesc = 600100979Srwatson mpe->mpe_function; 601100979Srwatson break; 602100979Srwatson case MAC_CREATE_DATAGRAM_FROM_IPQ: 603100979Srwatson mpc->mpc_ops->mpo_create_datagram_from_ipq = 604100979Srwatson mpe->mpe_function; 605100979Srwatson break; 606100979Srwatson case MAC_CREATE_FRAGMENT: 607100979Srwatson mpc->mpc_ops->mpo_create_fragment = 608100979Srwatson mpe->mpe_function; 609100979Srwatson break; 610100979Srwatson case MAC_CREATE_IFNET: 611100979Srwatson mpc->mpc_ops->mpo_create_ifnet = 612100979Srwatson mpe->mpe_function; 613100979Srwatson break; 614100979Srwatson case MAC_CREATE_IPQ: 615100979Srwatson mpc->mpc_ops->mpo_create_ipq = 616100979Srwatson mpe->mpe_function; 617100979Srwatson break; 618100979Srwatson case MAC_CREATE_MBUF_FROM_MBUF: 619100979Srwatson mpc->mpc_ops->mpo_create_mbuf_from_mbuf = 620100979Srwatson mpe->mpe_function; 621100979Srwatson break; 622100979Srwatson case MAC_CREATE_MBUF_LINKLAYER: 623100979Srwatson mpc->mpc_ops->mpo_create_mbuf_linklayer = 624100979Srwatson mpe->mpe_function; 625100979Srwatson break; 626100979Srwatson case MAC_CREATE_MBUF_FROM_BPFDESC: 627100979Srwatson mpc->mpc_ops->mpo_create_mbuf_from_bpfdesc = 628100979Srwatson mpe->mpe_function; 629100979Srwatson break; 630100979Srwatson case MAC_CREATE_MBUF_FROM_IFNET: 631100979Srwatson mpc->mpc_ops->mpo_create_mbuf_from_ifnet = 632100979Srwatson mpe->mpe_function; 633100979Srwatson break; 634100979Srwatson case MAC_CREATE_MBUF_MULTICAST_ENCAP: 635100979Srwatson mpc->mpc_ops->mpo_create_mbuf_multicast_encap = 636100979Srwatson mpe->mpe_function; 637100979Srwatson break; 638100979Srwatson case MAC_CREATE_MBUF_NETLAYER: 639100979Srwatson mpc->mpc_ops->mpo_create_mbuf_netlayer = 640100979Srwatson mpe->mpe_function; 641100979Srwatson break; 642100979Srwatson case MAC_FRAGMENT_MATCH: 643100979Srwatson mpc->mpc_ops->mpo_fragment_match = 644100979Srwatson mpe->mpe_function; 645100979Srwatson break; 646100979Srwatson case MAC_RELABEL_IFNET: 647100979Srwatson mpc->mpc_ops->mpo_relabel_ifnet = 648100979Srwatson mpe->mpe_function; 649100979Srwatson break; 650100979Srwatson case MAC_UPDATE_IPQ: 651100979Srwatson mpc->mpc_ops->mpo_update_ipq = 652100979Srwatson mpe->mpe_function; 653100979Srwatson break; 654100979Srwatson case MAC_CREATE_CRED: 655100979Srwatson mpc->mpc_ops->mpo_create_cred = 656100979Srwatson mpe->mpe_function; 657100979Srwatson break; 658100979Srwatson case MAC_EXECVE_TRANSITION: 659100979Srwatson mpc->mpc_ops->mpo_execve_transition = 660100979Srwatson mpe->mpe_function; 661100979Srwatson break; 662100979Srwatson case MAC_EXECVE_WILL_TRANSITION: 663100979Srwatson mpc->mpc_ops->mpo_execve_will_transition = 664100979Srwatson mpe->mpe_function; 665100979Srwatson break; 666100979Srwatson case MAC_CREATE_PROC0: 667100979Srwatson mpc->mpc_ops->mpo_create_proc0 = mpe->mpe_function; 668100979Srwatson break; 669100979Srwatson case MAC_CREATE_PROC1: 670100979Srwatson mpc->mpc_ops->mpo_create_proc1 = mpe->mpe_function; 671100979Srwatson break; 672100979Srwatson case MAC_RELABEL_CRED: 673100979Srwatson mpc->mpc_ops->mpo_relabel_cred = 674100979Srwatson mpe->mpe_function; 675100979Srwatson break; 676104338Srwatson case MAC_THREAD_USERRET: 677104338Srwatson mpc->mpc_ops->mpo_thread_userret = 678104338Srwatson mpe->mpe_function; 679104338Srwatson break; 680100979Srwatson case MAC_CHECK_BPFDESC_RECEIVE: 681100979Srwatson mpc->mpc_ops->mpo_check_bpfdesc_receive = 682100979Srwatson mpe->mpe_function; 683100979Srwatson break; 684100979Srwatson case MAC_CHECK_CRED_RELABEL: 685100979Srwatson mpc->mpc_ops->mpo_check_cred_relabel = 686100979Srwatson mpe->mpe_function; 687100979Srwatson break; 688100979Srwatson case MAC_CHECK_CRED_VISIBLE: 689100979Srwatson mpc->mpc_ops->mpo_check_cred_visible = 690100979Srwatson mpe->mpe_function; 691100979Srwatson break; 692100979Srwatson case MAC_CHECK_IFNET_RELABEL: 693100979Srwatson mpc->mpc_ops->mpo_check_ifnet_relabel = 694100979Srwatson mpe->mpe_function; 695100979Srwatson break; 696100979Srwatson case MAC_CHECK_IFNET_TRANSMIT: 697100979Srwatson mpc->mpc_ops->mpo_check_ifnet_transmit = 698100979Srwatson mpe->mpe_function; 699100979Srwatson break; 700100979Srwatson case MAC_CHECK_MOUNT_STAT: 701100979Srwatson mpc->mpc_ops->mpo_check_mount_stat = 702100979Srwatson mpe->mpe_function; 703100979Srwatson break; 704100979Srwatson case MAC_CHECK_PIPE_IOCTL: 705100979Srwatson mpc->mpc_ops->mpo_check_pipe_ioctl = 706100979Srwatson mpe->mpe_function; 707100979Srwatson break; 708102115Srwatson case MAC_CHECK_PIPE_POLL: 709102115Srwatson mpc->mpc_ops->mpo_check_pipe_poll = 710100979Srwatson mpe->mpe_function; 711100979Srwatson break; 712102115Srwatson case MAC_CHECK_PIPE_READ: 713102115Srwatson mpc->mpc_ops->mpo_check_pipe_read = 714102115Srwatson mpe->mpe_function; 715102115Srwatson break; 716100979Srwatson case MAC_CHECK_PIPE_RELABEL: 717100979Srwatson mpc->mpc_ops->mpo_check_pipe_relabel = 718100979Srwatson mpe->mpe_function; 719100979Srwatson break; 720102115Srwatson case MAC_CHECK_PIPE_STAT: 721102115Srwatson mpc->mpc_ops->mpo_check_pipe_stat = 722102115Srwatson mpe->mpe_function; 723102115Srwatson break; 724102115Srwatson case MAC_CHECK_PIPE_WRITE: 725102115Srwatson mpc->mpc_ops->mpo_check_pipe_write = 726102115Srwatson mpe->mpe_function; 727102115Srwatson break; 728100979Srwatson case MAC_CHECK_PROC_DEBUG: 729100979Srwatson mpc->mpc_ops->mpo_check_proc_debug = 730100979Srwatson mpe->mpe_function; 731100979Srwatson break; 732100979Srwatson case MAC_CHECK_PROC_SCHED: 733100979Srwatson mpc->mpc_ops->mpo_check_proc_sched = 734100979Srwatson mpe->mpe_function; 735100979Srwatson break; 736100979Srwatson case MAC_CHECK_PROC_SIGNAL: 737100979Srwatson mpc->mpc_ops->mpo_check_proc_signal = 738100979Srwatson mpe->mpe_function; 739100979Srwatson break; 740100979Srwatson case MAC_CHECK_SOCKET_BIND: 741100979Srwatson mpc->mpc_ops->mpo_check_socket_bind = 742100979Srwatson mpe->mpe_function; 743100979Srwatson break; 744100979Srwatson case MAC_CHECK_SOCKET_CONNECT: 745100979Srwatson mpc->mpc_ops->mpo_check_socket_connect = 746100979Srwatson mpe->mpe_function; 747100979Srwatson break; 748101933Srwatson case MAC_CHECK_SOCKET_DELIVER: 749101933Srwatson mpc->mpc_ops->mpo_check_socket_deliver = 750101933Srwatson mpe->mpe_function; 751101933Srwatson break; 752100979Srwatson case MAC_CHECK_SOCKET_LISTEN: 753100979Srwatson mpc->mpc_ops->mpo_check_socket_listen = 754100979Srwatson mpe->mpe_function; 755100979Srwatson break; 756100979Srwatson case MAC_CHECK_SOCKET_RELABEL: 757100979Srwatson mpc->mpc_ops->mpo_check_socket_relabel = 758100979Srwatson mpe->mpe_function; 759100979Srwatson break; 760100979Srwatson case MAC_CHECK_SOCKET_VISIBLE: 761100979Srwatson mpc->mpc_ops->mpo_check_socket_visible = 762100979Srwatson mpe->mpe_function; 763100979Srwatson break; 764100979Srwatson case MAC_CHECK_VNODE_ACCESS: 765100979Srwatson mpc->mpc_ops->mpo_check_vnode_access = 766100979Srwatson mpe->mpe_function; 767100979Srwatson break; 768100979Srwatson case MAC_CHECK_VNODE_CHDIR: 769100979Srwatson mpc->mpc_ops->mpo_check_vnode_chdir = 770100979Srwatson mpe->mpe_function; 771100979Srwatson break; 772100979Srwatson case MAC_CHECK_VNODE_CHROOT: 773100979Srwatson mpc->mpc_ops->mpo_check_vnode_chroot = 774100979Srwatson mpe->mpe_function; 775100979Srwatson break; 776100979Srwatson case MAC_CHECK_VNODE_CREATE: 777100979Srwatson mpc->mpc_ops->mpo_check_vnode_create = 778100979Srwatson mpe->mpe_function; 779100979Srwatson break; 780100979Srwatson case MAC_CHECK_VNODE_DELETE: 781100979Srwatson mpc->mpc_ops->mpo_check_vnode_delete = 782100979Srwatson mpe->mpe_function; 783100979Srwatson break; 784100979Srwatson case MAC_CHECK_VNODE_DELETEACL: 785100979Srwatson mpc->mpc_ops->mpo_check_vnode_deleteacl = 786100979Srwatson mpe->mpe_function; 787100979Srwatson break; 788100979Srwatson case MAC_CHECK_VNODE_EXEC: 789100979Srwatson mpc->mpc_ops->mpo_check_vnode_exec = 790100979Srwatson mpe->mpe_function; 791100979Srwatson break; 792100979Srwatson case MAC_CHECK_VNODE_GETACL: 793100979Srwatson mpc->mpc_ops->mpo_check_vnode_getacl = 794100979Srwatson mpe->mpe_function; 795100979Srwatson break; 796100979Srwatson case MAC_CHECK_VNODE_GETEXTATTR: 797100979Srwatson mpc->mpc_ops->mpo_check_vnode_getextattr = 798100979Srwatson mpe->mpe_function; 799100979Srwatson break; 800100979Srwatson case MAC_CHECK_VNODE_LOOKUP: 801100979Srwatson mpc->mpc_ops->mpo_check_vnode_lookup = 802100979Srwatson mpe->mpe_function; 803100979Srwatson break; 804100979Srwatson case MAC_CHECK_VNODE_MMAP_PERMS: 805100979Srwatson mpc->mpc_ops->mpo_check_vnode_mmap_perms = 806100979Srwatson mpe->mpe_function; 807100979Srwatson break; 808100979Srwatson case MAC_CHECK_VNODE_OPEN: 809100979Srwatson mpc->mpc_ops->mpo_check_vnode_open = 810100979Srwatson mpe->mpe_function; 811100979Srwatson break; 812102112Srwatson case MAC_CHECK_VNODE_POLL: 813102112Srwatson mpc->mpc_ops->mpo_check_vnode_poll = 814102112Srwatson mpe->mpe_function; 815102112Srwatson break; 816102112Srwatson case MAC_CHECK_VNODE_READ: 817102112Srwatson mpc->mpc_ops->mpo_check_vnode_read = 818102112Srwatson mpe->mpe_function; 819102112Srwatson break; 820100979Srwatson case MAC_CHECK_VNODE_READDIR: 821100979Srwatson mpc->mpc_ops->mpo_check_vnode_readdir = 822100979Srwatson mpe->mpe_function; 823100979Srwatson break; 824100979Srwatson case MAC_CHECK_VNODE_READLINK: 825100979Srwatson mpc->mpc_ops->mpo_check_vnode_readlink = 826100979Srwatson mpe->mpe_function; 827100979Srwatson break; 828100979Srwatson case MAC_CHECK_VNODE_RELABEL: 829100979Srwatson mpc->mpc_ops->mpo_check_vnode_relabel = 830100979Srwatson mpe->mpe_function; 831100979Srwatson break; 832100979Srwatson case MAC_CHECK_VNODE_RENAME_FROM: 833100979Srwatson mpc->mpc_ops->mpo_check_vnode_rename_from = 834100979Srwatson mpe->mpe_function; 835100979Srwatson break; 836100979Srwatson case MAC_CHECK_VNODE_RENAME_TO: 837100979Srwatson mpc->mpc_ops->mpo_check_vnode_rename_to = 838100979Srwatson mpe->mpe_function; 839100979Srwatson break; 840100979Srwatson case MAC_CHECK_VNODE_REVOKE: 841100979Srwatson mpc->mpc_ops->mpo_check_vnode_revoke = 842100979Srwatson mpe->mpe_function; 843100979Srwatson break; 844100979Srwatson case MAC_CHECK_VNODE_SETACL: 845100979Srwatson mpc->mpc_ops->mpo_check_vnode_setacl = 846100979Srwatson mpe->mpe_function; 847100979Srwatson break; 848100979Srwatson case MAC_CHECK_VNODE_SETEXTATTR: 849100979Srwatson mpc->mpc_ops->mpo_check_vnode_setextattr = 850100979Srwatson mpe->mpe_function; 851100979Srwatson break; 852100979Srwatson case MAC_CHECK_VNODE_SETFLAGS: 853100979Srwatson mpc->mpc_ops->mpo_check_vnode_setflags = 854100979Srwatson mpe->mpe_function; 855100979Srwatson break; 856100979Srwatson case MAC_CHECK_VNODE_SETMODE: 857100979Srwatson mpc->mpc_ops->mpo_check_vnode_setmode = 858100979Srwatson mpe->mpe_function; 859100979Srwatson break; 860100979Srwatson case MAC_CHECK_VNODE_SETOWNER: 861100979Srwatson mpc->mpc_ops->mpo_check_vnode_setowner = 862100979Srwatson mpe->mpe_function; 863100979Srwatson break; 864100979Srwatson case MAC_CHECK_VNODE_SETUTIMES: 865100979Srwatson mpc->mpc_ops->mpo_check_vnode_setutimes = 866100979Srwatson mpe->mpe_function; 867100979Srwatson break; 868100979Srwatson case MAC_CHECK_VNODE_STAT: 869100979Srwatson mpc->mpc_ops->mpo_check_vnode_stat = 870100979Srwatson mpe->mpe_function; 871100979Srwatson break; 872102112Srwatson case MAC_CHECK_VNODE_WRITE: 873102112Srwatson mpc->mpc_ops->mpo_check_vnode_write = 874102112Srwatson mpe->mpe_function; 875102112Srwatson break; 876100979Srwatson/* 877100979Srwatson default: 878100979Srwatson printf("MAC policy `%s': unknown operation %d\n", 879100979Srwatson mpc->mpc_name, mpe->mpe_constant); 880100979Srwatson return (EINVAL); 881100979Srwatson*/ 882100979Srwatson } 883100979Srwatson } 884100979Srwatson MAC_POLICY_LIST_LOCK(); 885100979Srwatson if (mac_policy_list_busy > 0) { 886100979Srwatson MAC_POLICY_LIST_UNLOCK(); 887100979Srwatson FREE(mpc->mpc_ops, M_MACOPVEC); 888100979Srwatson mpc->mpc_ops = NULL; 889100979Srwatson return (EBUSY); 890100979Srwatson } 891100979Srwatson LIST_FOREACH(tmpc, &mac_policy_list, mpc_list) { 892100979Srwatson if (strcmp(tmpc->mpc_name, mpc->mpc_name) == 0) { 893100979Srwatson MAC_POLICY_LIST_UNLOCK(); 894100979Srwatson FREE(mpc->mpc_ops, M_MACOPVEC); 895100979Srwatson mpc->mpc_ops = NULL; 896100979Srwatson return (EEXIST); 897100979Srwatson } 898100979Srwatson } 899100979Srwatson if (mpc->mpc_field_off != NULL) { 900100979Srwatson slot = ffs(mac_policy_offsets_free); 901100979Srwatson if (slot == 0) { 902100979Srwatson MAC_POLICY_LIST_UNLOCK(); 903100979Srwatson FREE(mpc->mpc_ops, M_MACOPVEC); 904100979Srwatson mpc->mpc_ops = NULL; 905100979Srwatson return (ENOMEM); 906100979Srwatson } 907100979Srwatson slot--; 908100979Srwatson mac_policy_offsets_free &= ~(1 << slot); 909100979Srwatson *mpc->mpc_field_off = slot; 910100979Srwatson } 911100979Srwatson mpc->mpc_runtime_flags |= MPC_RUNTIME_FLAG_REGISTERED; 912100979Srwatson LIST_INSERT_HEAD(&mac_policy_list, mpc, mpc_list); 913100979Srwatson 914100979Srwatson /* Per-policy initialization. */ 915100979Srwatson if (mpc->mpc_ops->mpo_init != NULL) 916100979Srwatson (*(mpc->mpc_ops->mpo_init))(mpc); 917100979Srwatson MAC_POLICY_LIST_UNLOCK(); 918100979Srwatson 919100979Srwatson printf("Security policy loaded: %s (%s)\n", mpc->mpc_fullname, 920100979Srwatson mpc->mpc_name); 921100979Srwatson 922100979Srwatson return (0); 923100979Srwatson} 924100979Srwatson 925100979Srwatsonstatic int 926100979Srwatsonmac_policy_unregister(struct mac_policy_conf *mpc) 927100979Srwatson{ 928100979Srwatson 929100979Srwatson#if 0 930100979Srwatson /* 931100979Srwatson * Don't allow unloading modules with private data. 932100979Srwatson */ 933100979Srwatson if (mpc->mpc_field_off != NULL) 934100979Srwatson return (EBUSY); 935100979Srwatson#endif 936100979Srwatson if ((mpc->mpc_loadtime_flags & MPC_LOADTIME_FLAG_UNLOADOK) == 0) 937100979Srwatson return (EBUSY); 938100979Srwatson MAC_POLICY_LIST_LOCK(); 939100979Srwatson if (mac_policy_list_busy > 0) { 940100979Srwatson MAC_POLICY_LIST_UNLOCK(); 941100979Srwatson return (EBUSY); 942100979Srwatson } 943100979Srwatson if (mpc->mpc_ops->mpo_destroy != NULL) 944100979Srwatson (*(mpc->mpc_ops->mpo_destroy))(mpc); 945100979Srwatson 946100979Srwatson LIST_REMOVE(mpc, mpc_list); 947100979Srwatson MAC_POLICY_LIST_UNLOCK(); 948100979Srwatson 949100979Srwatson FREE(mpc->mpc_ops, M_MACOPVEC); 950100979Srwatson mpc->mpc_ops = NULL; 951100979Srwatson 952100979Srwatson printf("Security policy unload: %s (%s)\n", mpc->mpc_fullname, 953100979Srwatson mpc->mpc_name); 954100979Srwatson 955100979Srwatson return (0); 956100979Srwatson} 957100979Srwatson 958100979Srwatson/* 959100979Srwatson * Define an error value precedence, and given two arguments, selects the 960100979Srwatson * value with the higher precedence. 961100979Srwatson */ 962100979Srwatsonstatic int 963100979Srwatsonerror_select(int error1, int error2) 964100979Srwatson{ 965100979Srwatson 966100979Srwatson /* Certain decision-making errors take top priority. */ 967100979Srwatson if (error1 == EDEADLK || error2 == EDEADLK) 968100979Srwatson return (EDEADLK); 969100979Srwatson 970100979Srwatson /* Invalid arguments should be reported where possible. */ 971100979Srwatson if (error1 == EINVAL || error2 == EINVAL) 972100979Srwatson return (EINVAL); 973100979Srwatson 974100979Srwatson /* Precedence goes to "visibility", with both process and file. */ 975100979Srwatson if (error1 == ESRCH || error2 == ESRCH) 976100979Srwatson return (ESRCH); 977100979Srwatson 978100979Srwatson if (error1 == ENOENT || error2 == ENOENT) 979100979Srwatson return (ENOENT); 980100979Srwatson 981100979Srwatson /* Precedence goes to DAC/MAC protections. */ 982100979Srwatson if (error1 == EACCES || error2 == EACCES) 983100979Srwatson return (EACCES); 984100979Srwatson 985100979Srwatson /* Precedence goes to privilege. */ 986100979Srwatson if (error1 == EPERM || error2 == EPERM) 987100979Srwatson return (EPERM); 988100979Srwatson 989100979Srwatson /* Precedence goes to error over success; otherwise, arbitrary. */ 990100979Srwatson if (error1 != 0) 991100979Srwatson return (error1); 992100979Srwatson return (error2); 993100979Srwatson} 994100979Srwatson 995100979Srwatsonvoid 996100979Srwatsonmac_update_devfsdirent(struct devfs_dirent *de, struct vnode *vp) 997100979Srwatson{ 998100979Srwatson 999100979Srwatson MAC_PERFORM(update_devfsdirent, de, &de->de_label, vp, &vp->v_label); 1000100979Srwatson} 1001100979Srwatson 1002100979Srwatsonvoid 1003100979Srwatsonmac_update_procfsvnode(struct vnode *vp, struct ucred *cred) 1004100979Srwatson{ 1005100979Srwatson 1006100979Srwatson MAC_PERFORM(update_procfsvnode, vp, &vp->v_label, cred); 1007100979Srwatson} 1008100979Srwatson 1009100979Srwatson/* 1010100979Srwatson * Support callout for policies that manage their own externalization 1011100979Srwatson * using extended attributes. 1012100979Srwatson */ 1013100979Srwatsonstatic int 1014100979Srwatsonmac_update_vnode_from_extattr(struct vnode *vp, struct mount *mp) 1015100979Srwatson{ 1016100979Srwatson int error; 1017100979Srwatson 1018100979Srwatson MAC_CHECK(update_vnode_from_extattr, vp, &vp->v_label, mp, 1019100979Srwatson &mp->mnt_fslabel); 1020100979Srwatson 1021100979Srwatson return (error); 1022100979Srwatson} 1023100979Srwatson 1024100979Srwatson/* 1025100979Srwatson * Given an externalized mac label, internalize it and stamp it on a 1026100979Srwatson * vnode. 1027100979Srwatson */ 1028100979Srwatsonstatic int 1029100979Srwatsonmac_update_vnode_from_externalized(struct vnode *vp, struct mac *extmac) 1030100979Srwatson{ 1031100979Srwatson int error; 1032100979Srwatson 1033100979Srwatson MAC_CHECK(update_vnode_from_externalized, vp, &vp->v_label, extmac); 1034100979Srwatson 1035100979Srwatson return (error); 1036100979Srwatson} 1037100979Srwatson 1038100979Srwatson/* 1039100979Srwatson * Call out to individual policies to update the label in a vnode from 1040100979Srwatson * the mountpoint. 1041100979Srwatson */ 1042100979Srwatsonvoid 1043100979Srwatsonmac_update_vnode_from_mount(struct vnode *vp, struct mount *mp) 1044100979Srwatson{ 1045100979Srwatson 1046100979Srwatson MAC_PERFORM(update_vnode_from_mount, vp, &vp->v_label, mp, 1047100979Srwatson &mp->mnt_fslabel); 1048100979Srwatson 1049101308Sjeff ASSERT_VOP_LOCKED(vp, "mac_update_vnode_from_mount"); 1050100979Srwatson if (mac_cache_fslabel_in_vnode) 1051101308Sjeff vp->v_vflag |= VV_CACHEDLABEL; 1052100979Srwatson} 1053100979Srwatson 1054100979Srwatson/* 1055100979Srwatson * Implementation of VOP_REFRESHLABEL() that relies on extended attributes 1056100979Srwatson * to store label data. Can be referenced by filesystems supporting 1057100979Srwatson * extended attributes. 1058100979Srwatson */ 1059100979Srwatsonint 1060100979Srwatsonvop_stdrefreshlabel_ea(struct vop_refreshlabel_args *ap) 1061100979Srwatson{ 1062100979Srwatson struct vnode *vp = ap->a_vp; 1063100979Srwatson struct mac extmac; 1064100979Srwatson int buflen, error; 1065100979Srwatson 1066100979Srwatson ASSERT_VOP_LOCKED(vp, "vop_stdrefreshlabel_ea"); 1067100979Srwatson 1068100979Srwatson /* 1069100979Srwatson * Call out to external policies first. Order doesn't really 1070100979Srwatson * matter, as long as failure of one assures failure of all. 1071100979Srwatson */ 1072100979Srwatson error = mac_update_vnode_from_extattr(vp, vp->v_mount); 1073100979Srwatson if (error) 1074100979Srwatson return (error); 1075100979Srwatson 1076100979Srwatson buflen = sizeof(extmac); 1077100979Srwatson error = vn_extattr_get(vp, IO_NODELOCKED, 1078100979Srwatson FREEBSD_MAC_EXTATTR_NAMESPACE, FREEBSD_MAC_EXTATTR_NAME, &buflen, 1079100979Srwatson (char *)&extmac, curthread); 1080100979Srwatson switch (error) { 1081100979Srwatson case 0: 1082100979Srwatson /* Got it */ 1083100979Srwatson break; 1084100979Srwatson 1085100979Srwatson case ENOATTR: 1086100979Srwatson /* 1087100979Srwatson * Use the label from the mount point. 1088100979Srwatson */ 1089100979Srwatson mac_update_vnode_from_mount(vp, vp->v_mount); 1090100979Srwatson return (0); 1091100979Srwatson 1092100979Srwatson case EOPNOTSUPP: 1093100979Srwatson default: 1094100979Srwatson /* Fail horribly. */ 1095100979Srwatson return (error); 1096100979Srwatson } 1097100979Srwatson 1098100979Srwatson if (buflen != sizeof(extmac)) 1099100979Srwatson error = EPERM; /* Fail very closed. */ 1100100979Srwatson if (error == 0) 1101100979Srwatson error = mac_update_vnode_from_externalized(vp, &extmac); 1102100979Srwatson if (error == 0) 1103101308Sjeff vp->v_vflag |= VV_CACHEDLABEL; 1104100979Srwatson else { 1105100979Srwatson struct vattr va; 1106100979Srwatson 1107100979Srwatson printf("Corrupted label on %s", 1108100979Srwatson vp->v_mount->mnt_stat.f_mntonname); 1109100979Srwatson if (VOP_GETATTR(vp, &va, curthread->td_ucred, curthread) == 0) 1110100979Srwatson printf(" inum %ld", va.va_fileid); 1111104268Srwatson#ifdef MAC_DEBUG 1112100979Srwatson if (mac_debug_label_fallback) { 1113100979Srwatson printf(", falling back.\n"); 1114100979Srwatson mac_update_vnode_from_mount(vp, vp->v_mount); 1115100979Srwatson error = 0; 1116100979Srwatson } else { 1117104268Srwatson#endif 1118100979Srwatson printf(".\n"); 1119100979Srwatson error = EPERM; 1120104268Srwatson#ifdef MAC_DEBUG 1121100979Srwatson } 1122104268Srwatson#endif 1123100979Srwatson } 1124100979Srwatson 1125100979Srwatson return (error); 1126100979Srwatson} 1127100979Srwatson 1128100979Srwatson/* 1129100979Srwatson * Make sure the vnode label is up-to-date. If EOPNOTSUPP, then we handle 1130100979Srwatson * the labeling activity outselves. Filesystems should be careful not 1131100979Srwatson * to change their minds regarding whether they support vop_refreshlabel() 1132100979Srwatson * for a vnode or not. Don't cache the vnode here, allow the file 1133100979Srwatson * system code to determine if it's safe to cache. If we update from 1134100979Srwatson * the mount, don't cache since a change to the mount label should affect 1135100979Srwatson * all vnodes. 1136100979Srwatson */ 1137100979Srwatsonstatic int 1138100979Srwatsonvn_refreshlabel(struct vnode *vp, struct ucred *cred) 1139100979Srwatson{ 1140100979Srwatson int error; 1141100979Srwatson 1142100979Srwatson ASSERT_VOP_LOCKED(vp, "vn_refreshlabel"); 1143100979Srwatson 1144100979Srwatson if (vp->v_mount == NULL) { 1145100979Srwatson/* 1146100979Srwatson Eventually, we probably want to special-case refreshing 1147100979Srwatson of deadfs vnodes, and if there's a lock-free race somewhere, 1148100979Srwatson that case might be handled here. 1149100979Srwatson 1150100979Srwatson mac_update_vnode_deadfs(vp); 1151100979Srwatson return (0); 1152100979Srwatson */ 1153100979Srwatson /* printf("vn_refreshlabel: null v_mount\n"); */ 1154103314Snjl if (vp->v_type != VNON) 1155100979Srwatson printf( 1156103314Snjl "vn_refreshlabel: null v_mount with non-VNON\n"); 1157100979Srwatson return (EBADF); 1158100979Srwatson } 1159100979Srwatson 1160101308Sjeff if (vp->v_vflag & VV_CACHEDLABEL) { 1161100979Srwatson mac_vnode_label_cache_hits++; 1162100979Srwatson return (0); 1163100979Srwatson } else 1164100979Srwatson mac_vnode_label_cache_misses++; 1165100979Srwatson 1166100979Srwatson if ((vp->v_mount->mnt_flag & MNT_MULTILABEL) == 0) { 1167100979Srwatson mac_update_vnode_from_mount(vp, vp->v_mount); 1168100979Srwatson return (0); 1169100979Srwatson } 1170100979Srwatson 1171100979Srwatson error = VOP_REFRESHLABEL(vp, cred, curthread); 1172100979Srwatson switch (error) { 1173100979Srwatson case EOPNOTSUPP: 1174100979Srwatson /* 1175100979Srwatson * If labels are not supported on this vnode, fall back to 1176100979Srwatson * the label in the mount and propagate it to the vnode. 1177100979Srwatson * There should probably be some sort of policy/flag/decision 1178100979Srwatson * about doing this. 1179100979Srwatson */ 1180100979Srwatson mac_update_vnode_from_mount(vp, vp->v_mount); 1181100979Srwatson error = 0; 1182100979Srwatson default: 1183100979Srwatson return (error); 1184100979Srwatson } 1185100979Srwatson} 1186100979Srwatson 1187100979Srwatson/* 1188100979Srwatson * Helper function for file systems using the vop_std*_ea() calls. This 1189100979Srwatson * function must be called after EA service is available for the vnode, 1190100979Srwatson * but before it's hooked up to the namespace so that the node persists 1191100979Srwatson * if there's a crash, or before it can be accessed. On successful 1192100979Srwatson * commit of the label to disk (etc), do cache the label. 1193100979Srwatson */ 1194100979Srwatsonint 1195100979Srwatsonvop_stdcreatevnode_ea(struct vnode *dvp, struct vnode *tvp, struct ucred *cred) 1196100979Srwatson{ 1197100979Srwatson struct mac extmac; 1198100979Srwatson int error; 1199100979Srwatson 1200101308Sjeff ASSERT_VOP_LOCKED(tvp, "vop_stdcreatevnode_ea"); 1201100979Srwatson if ((dvp->v_mount->mnt_flag & MNT_MULTILABEL) == 0) { 1202100979Srwatson mac_update_vnode_from_mount(tvp, tvp->v_mount); 1203100979Srwatson } else { 1204100979Srwatson error = vn_refreshlabel(dvp, cred); 1205100979Srwatson if (error) 1206100979Srwatson return (error); 1207100979Srwatson 1208100979Srwatson /* 1209100979Srwatson * Stick the label in the vnode. Then try to write to 1210100979Srwatson * disk. If we fail, return a failure to abort the 1211100979Srwatson * create operation. Really, this failure shouldn't 1212100979Srwatson * happen except in fairly unusual circumstances (out 1213100979Srwatson * of disk, etc). 1214100979Srwatson */ 1215100979Srwatson mac_create_vnode(cred, dvp, tvp); 1216100979Srwatson 1217100979Srwatson error = mac_stdcreatevnode_ea(tvp); 1218100979Srwatson if (error) 1219100979Srwatson return (error); 1220100979Srwatson 1221100979Srwatson /* 1222100979Srwatson * XXX: Eventually this will go away and all policies will 1223100979Srwatson * directly manage their extended attributes. 1224100979Srwatson */ 1225100979Srwatson error = mac_externalize(&tvp->v_label, &extmac); 1226100979Srwatson if (error) 1227100979Srwatson return (error); 1228100979Srwatson 1229100979Srwatson error = vn_extattr_set(tvp, IO_NODELOCKED, 1230100979Srwatson FREEBSD_MAC_EXTATTR_NAMESPACE, FREEBSD_MAC_EXTATTR_NAME, 1231100979Srwatson sizeof(extmac), (char *)&extmac, curthread); 1232100979Srwatson if (error == 0) 1233101308Sjeff tvp->v_vflag |= VV_CACHEDLABEL; 1234100979Srwatson else { 1235100979Srwatson#if 0 1236100979Srwatson /* 1237100979Srwatson * In theory, we could have fall-back behavior here. 1238100979Srwatson * It would probably be incorrect. 1239100979Srwatson */ 1240100979Srwatson#endif 1241100979Srwatson return (error); 1242100979Srwatson } 1243100979Srwatson } 1244100979Srwatson 1245100979Srwatson return (0); 1246100979Srwatson} 1247100979Srwatson 1248100979Srwatsonvoid 1249100979Srwatsonmac_execve_transition(struct ucred *old, struct ucred *new, struct vnode *vp) 1250100979Srwatson{ 1251100979Srwatson int error; 1252100979Srwatson 1253100979Srwatson ASSERT_VOP_LOCKED(vp, "mac_execve_transition"); 1254100979Srwatson 1255100979Srwatson error = vn_refreshlabel(vp, old); 1256100979Srwatson if (error) { 1257100979Srwatson printf("mac_execve_transition: vn_refreshlabel returned %d\n", 1258100979Srwatson error); 1259100979Srwatson printf("mac_execve_transition: using old vnode label\n"); 1260100979Srwatson } 1261100979Srwatson 1262100979Srwatson MAC_PERFORM(execve_transition, old, new, vp, &vp->v_label); 1263100979Srwatson} 1264100979Srwatson 1265100979Srwatsonint 1266100979Srwatsonmac_execve_will_transition(struct ucred *old, struct vnode *vp) 1267100979Srwatson{ 1268100979Srwatson int error, result; 1269100979Srwatson 1270100979Srwatson error = vn_refreshlabel(vp, old); 1271100979Srwatson if (error) 1272100979Srwatson return (error); 1273100979Srwatson 1274100979Srwatson result = 0; 1275100979Srwatson MAC_BOOLEAN(execve_will_transition, ||, old, vp, &vp->v_label); 1276100979Srwatson 1277100979Srwatson return (result); 1278100979Srwatson} 1279100979Srwatson 1280100979Srwatsonstatic void 1281100979Srwatsonmac_init_label(struct label *label) 1282100979Srwatson{ 1283100979Srwatson 1284100979Srwatson bzero(label, sizeof(*label)); 1285100979Srwatson label->l_flags = MAC_FLAG_INITIALIZED; 1286100979Srwatson} 1287100979Srwatson 1288100979Srwatsonstatic void 1289100979Srwatsonmac_init_structmac(struct mac *mac) 1290100979Srwatson{ 1291100979Srwatson 1292100979Srwatson bzero(mac, sizeof(*mac)); 1293100979Srwatson mac->m_macflags = MAC_FLAG_INITIALIZED; 1294100979Srwatson} 1295100979Srwatson 1296100979Srwatsonstatic void 1297100979Srwatsonmac_destroy_label(struct label *label) 1298100979Srwatson{ 1299100979Srwatson 1300100979Srwatson KASSERT(label->l_flags & MAC_FLAG_INITIALIZED, 1301100979Srwatson ("destroying uninitialized label")); 1302100979Srwatson 1303100979Srwatson bzero(label, sizeof(*label)); 1304100979Srwatson /* implicit: label->l_flags &= ~MAC_FLAG_INITIALIZED; */ 1305100979Srwatson} 1306100979Srwatson 1307100979Srwatsonint 1308100979Srwatsonmac_init_mbuf(struct mbuf *m, int how) 1309100979Srwatson{ 1310100979Srwatson KASSERT(m->m_flags & M_PKTHDR, ("mac_init_mbuf on non-header mbuf")); 1311100979Srwatson 1312100979Srwatson /* "how" is one of M_(TRY|DONT)WAIT */ 1313100979Srwatson mac_init_label(&m->m_pkthdr.label); 1314104514Srwatson MAC_PERFORM(init_mbuf_label, &m->m_pkthdr.label, how); 1315101988Srwatson#ifdef MAC_DEBUG 1316100979Srwatson atomic_add_int(&nmacmbufs, 1); 1317101988Srwatson#endif 1318100979Srwatson return (0); 1319100979Srwatson} 1320100979Srwatson 1321100979Srwatsonvoid 1322100979Srwatsonmac_destroy_mbuf(struct mbuf *m) 1323100979Srwatson{ 1324100979Srwatson 1325104514Srwatson MAC_PERFORM(destroy_mbuf_label, &m->m_pkthdr.label); 1326100979Srwatson mac_destroy_label(&m->m_pkthdr.label); 1327101988Srwatson#ifdef MAC_DEBUG 1328100979Srwatson atomic_subtract_int(&nmacmbufs, 1); 1329101988Srwatson#endif 1330100979Srwatson} 1331100979Srwatson 1332100979Srwatsonvoid 1333100979Srwatsonmac_init_cred(struct ucred *cr) 1334100979Srwatson{ 1335100979Srwatson 1336100979Srwatson mac_init_label(&cr->cr_label); 1337104514Srwatson MAC_PERFORM(init_cred_label, &cr->cr_label); 1338101988Srwatson#ifdef MAC_DEBUG 1339100979Srwatson atomic_add_int(&nmaccreds, 1); 1340101988Srwatson#endif 1341100979Srwatson} 1342100979Srwatson 1343100979Srwatsonvoid 1344100979Srwatsonmac_destroy_cred(struct ucred *cr) 1345100979Srwatson{ 1346100979Srwatson 1347104514Srwatson MAC_PERFORM(destroy_cred_label, &cr->cr_label); 1348100979Srwatson mac_destroy_label(&cr->cr_label); 1349101988Srwatson#ifdef MAC_DEBUG 1350100979Srwatson atomic_subtract_int(&nmaccreds, 1); 1351101988Srwatson#endif 1352100979Srwatson} 1353100979Srwatson 1354100979Srwatsonvoid 1355100979Srwatsonmac_init_ifnet(struct ifnet *ifp) 1356100979Srwatson{ 1357100979Srwatson 1358100979Srwatson mac_init_label(&ifp->if_label); 1359104514Srwatson MAC_PERFORM(init_ifnet_label, &ifp->if_label); 1360101988Srwatson#ifdef MAC_DEBUG 1361100979Srwatson atomic_add_int(&nmacifnets, 1); 1362101988Srwatson#endif 1363100979Srwatson} 1364100979Srwatson 1365100979Srwatsonvoid 1366100979Srwatsonmac_destroy_ifnet(struct ifnet *ifp) 1367100979Srwatson{ 1368100979Srwatson 1369104514Srwatson MAC_PERFORM(destroy_ifnet_label, &ifp->if_label); 1370100979Srwatson mac_destroy_label(&ifp->if_label); 1371101988Srwatson#ifdef MAC_DEBUG 1372100979Srwatson atomic_subtract_int(&nmacifnets, 1); 1373101988Srwatson#endif 1374100979Srwatson} 1375100979Srwatson 1376100979Srwatsonvoid 1377100979Srwatsonmac_init_ipq(struct ipq *ipq) 1378100979Srwatson{ 1379100979Srwatson 1380100979Srwatson mac_init_label(&ipq->ipq_label); 1381104514Srwatson MAC_PERFORM(init_ipq_label, &ipq->ipq_label); 1382101988Srwatson#ifdef MAC_DEBUG 1383100979Srwatson atomic_add_int(&nmacipqs, 1); 1384101988Srwatson#endif 1385100979Srwatson} 1386100979Srwatson 1387100979Srwatsonvoid 1388100979Srwatsonmac_destroy_ipq(struct ipq *ipq) 1389100979Srwatson{ 1390100979Srwatson 1391104514Srwatson MAC_PERFORM(destroy_ipq_label, &ipq->ipq_label); 1392100979Srwatson mac_destroy_label(&ipq->ipq_label); 1393101988Srwatson#ifdef MAC_DEBUG 1394100979Srwatson atomic_subtract_int(&nmacipqs, 1); 1395101988Srwatson#endif 1396100979Srwatson} 1397100979Srwatson 1398100979Srwatsonvoid 1399100979Srwatsonmac_init_socket(struct socket *socket) 1400100979Srwatson{ 1401100979Srwatson 1402100979Srwatson mac_init_label(&socket->so_label); 1403100979Srwatson mac_init_label(&socket->so_peerlabel); 1404104514Srwatson MAC_PERFORM(init_socket_label, &socket->so_label); 1405104514Srwatson MAC_PERFORM(init_socket_peer_label, &socket->so_peerlabel); 1406101988Srwatson#ifdef MAC_DEBUG 1407100979Srwatson atomic_add_int(&nmacsockets, 1); 1408101988Srwatson#endif 1409100979Srwatson} 1410100979Srwatson 1411100979Srwatsonvoid 1412100979Srwatsonmac_destroy_socket(struct socket *socket) 1413100979Srwatson{ 1414100979Srwatson 1415104514Srwatson MAC_PERFORM(destroy_socket_label, &socket->so_label); 1416104514Srwatson MAC_PERFORM(destroy_socket_peer_label, &socket->so_peerlabel); 1417100979Srwatson mac_destroy_label(&socket->so_label); 1418100979Srwatson mac_destroy_label(&socket->so_peerlabel); 1419101988Srwatson#ifdef MAC_DEBUG 1420100979Srwatson atomic_subtract_int(&nmacsockets, 1); 1421101988Srwatson#endif 1422100979Srwatson} 1423100979Srwatson 1424100979Srwatsonvoid 1425100979Srwatsonmac_init_pipe(struct pipe *pipe) 1426100979Srwatson{ 1427100979Srwatson struct label *label; 1428100979Srwatson 1429100979Srwatson label = malloc(sizeof(struct label), M_MACPIPELABEL, M_ZERO|M_WAITOK); 1430100979Srwatson mac_init_label(label); 1431100979Srwatson pipe->pipe_label = label; 1432100979Srwatson pipe->pipe_peer->pipe_label = label; 1433104514Srwatson MAC_PERFORM(init_pipe_label, pipe->pipe_label); 1434101988Srwatson#ifdef MAC_DEBUG 1435100979Srwatson atomic_add_int(&nmacpipes, 1); 1436101988Srwatson#endif 1437100979Srwatson} 1438100979Srwatson 1439100979Srwatsonvoid 1440100979Srwatsonmac_destroy_pipe(struct pipe *pipe) 1441100979Srwatson{ 1442100979Srwatson 1443104514Srwatson MAC_PERFORM(destroy_pipe_label, pipe->pipe_label); 1444100979Srwatson mac_destroy_label(pipe->pipe_label); 1445100979Srwatson free(pipe->pipe_label, M_MACPIPELABEL); 1446101988Srwatson#ifdef MAC_DEBUG 1447100979Srwatson atomic_subtract_int(&nmacpipes, 1); 1448101988Srwatson#endif 1449100979Srwatson} 1450100979Srwatson 1451100979Srwatsonvoid 1452100979Srwatsonmac_init_bpfdesc(struct bpf_d *bpf_d) 1453100979Srwatson{ 1454100979Srwatson 1455100979Srwatson mac_init_label(&bpf_d->bd_label); 1456104514Srwatson MAC_PERFORM(init_bpfdesc_label, &bpf_d->bd_label); 1457101988Srwatson#ifdef MAC_DEBUG 1458100979Srwatson atomic_add_int(&nmacbpfdescs, 1); 1459101988Srwatson#endif 1460100979Srwatson} 1461100979Srwatson 1462100979Srwatsonvoid 1463100979Srwatsonmac_destroy_bpfdesc(struct bpf_d *bpf_d) 1464100979Srwatson{ 1465100979Srwatson 1466104514Srwatson MAC_PERFORM(destroy_bpfdesc_label, &bpf_d->bd_label); 1467100979Srwatson mac_destroy_label(&bpf_d->bd_label); 1468101988Srwatson#ifdef MAC_DEBUG 1469100979Srwatson atomic_subtract_int(&nmacbpfdescs, 1); 1470101988Srwatson#endif 1471100979Srwatson} 1472100979Srwatson 1473100979Srwatsonvoid 1474100979Srwatsonmac_init_mount(struct mount *mp) 1475100979Srwatson{ 1476100979Srwatson 1477100979Srwatson mac_init_label(&mp->mnt_mntlabel); 1478100979Srwatson mac_init_label(&mp->mnt_fslabel); 1479104514Srwatson MAC_PERFORM(init_mount_label, &mp->mnt_mntlabel); 1480104514Srwatson MAC_PERFORM(init_mount_fs_label, &mp->mnt_fslabel); 1481101988Srwatson#ifdef MAC_DEBUG 1482100979Srwatson atomic_add_int(&nmacmounts, 1); 1483101988Srwatson#endif 1484100979Srwatson} 1485100979Srwatson 1486100979Srwatsonvoid 1487100979Srwatsonmac_destroy_mount(struct mount *mp) 1488100979Srwatson{ 1489100979Srwatson 1490104514Srwatson MAC_PERFORM(destroy_mount_label, &mp->mnt_mntlabel); 1491104514Srwatson MAC_PERFORM(destroy_mount_fs_label, &mp->mnt_fslabel); 1492100979Srwatson mac_destroy_label(&mp->mnt_fslabel); 1493100979Srwatson mac_destroy_label(&mp->mnt_mntlabel); 1494101988Srwatson#ifdef MAC_DEBUG 1495100979Srwatson atomic_subtract_int(&nmacmounts, 1); 1496101988Srwatson#endif 1497100979Srwatson} 1498100979Srwatson 1499100979Srwatsonstatic void 1500100979Srwatsonmac_init_temp(struct label *label) 1501100979Srwatson{ 1502100979Srwatson 1503100979Srwatson mac_init_label(label); 1504104514Srwatson MAC_PERFORM(init_temp_label, label); 1505101988Srwatson#ifdef MAC_DEBUG 1506100979Srwatson atomic_add_int(&nmactemp, 1); 1507101988Srwatson#endif 1508100979Srwatson} 1509100979Srwatson 1510100979Srwatsonstatic void 1511100979Srwatsonmac_destroy_temp(struct label *label) 1512100979Srwatson{ 1513100979Srwatson 1514104514Srwatson MAC_PERFORM(destroy_temp_label, label); 1515100979Srwatson mac_destroy_label(label); 1516101988Srwatson#ifdef MAC_DEBUG 1517100979Srwatson atomic_subtract_int(&nmactemp, 1); 1518101988Srwatson#endif 1519100979Srwatson} 1520100979Srwatson 1521100979Srwatsonvoid 1522100979Srwatsonmac_init_vnode(struct vnode *vp) 1523100979Srwatson{ 1524100979Srwatson 1525100979Srwatson mac_init_label(&vp->v_label); 1526104514Srwatson MAC_PERFORM(init_vnode_label, &vp->v_label); 1527101988Srwatson#ifdef MAC_DEBUG 1528100979Srwatson atomic_add_int(&nmacvnodes, 1); 1529101988Srwatson#endif 1530100979Srwatson} 1531100979Srwatson 1532100979Srwatsonvoid 1533100979Srwatsonmac_destroy_vnode(struct vnode *vp) 1534100979Srwatson{ 1535100979Srwatson 1536104514Srwatson MAC_PERFORM(destroy_vnode_label, &vp->v_label); 1537100979Srwatson mac_destroy_label(&vp->v_label); 1538101988Srwatson#ifdef MAC_DEBUG 1539100979Srwatson atomic_subtract_int(&nmacvnodes, 1); 1540101988Srwatson#endif 1541100979Srwatson} 1542100979Srwatson 1543100979Srwatsonvoid 1544100979Srwatsonmac_init_devfsdirent(struct devfs_dirent *de) 1545100979Srwatson{ 1546100979Srwatson 1547100979Srwatson mac_init_label(&de->de_label); 1548104514Srwatson MAC_PERFORM(init_devfsdirent_label, &de->de_label); 1549101988Srwatson#ifdef MAC_DEBUG 1550100979Srwatson atomic_add_int(&nmacdevfsdirents, 1); 1551101988Srwatson#endif 1552100979Srwatson} 1553100979Srwatson 1554100979Srwatsonvoid 1555100979Srwatsonmac_destroy_devfsdirent(struct devfs_dirent *de) 1556100979Srwatson{ 1557100979Srwatson 1558104514Srwatson MAC_PERFORM(destroy_devfsdirent_label, &de->de_label); 1559100979Srwatson mac_destroy_label(&de->de_label); 1560101988Srwatson#ifdef MAC_DEBUG 1561100979Srwatson atomic_subtract_int(&nmacdevfsdirents, 1); 1562101988Srwatson#endif 1563100979Srwatson} 1564100979Srwatson 1565100979Srwatsonstatic int 1566100979Srwatsonmac_externalize(struct label *label, struct mac *mac) 1567100979Srwatson{ 1568100979Srwatson int error; 1569100979Srwatson 1570100979Srwatson mac_init_structmac(mac); 1571100979Srwatson MAC_CHECK(externalize, label, mac); 1572100979Srwatson 1573100979Srwatson return (error); 1574100979Srwatson} 1575100979Srwatson 1576100979Srwatsonstatic int 1577100979Srwatsonmac_internalize(struct label *label, struct mac *mac) 1578100979Srwatson{ 1579100979Srwatson int error; 1580100979Srwatson 1581100979Srwatson mac_init_temp(label); 1582100979Srwatson MAC_CHECK(internalize, label, mac); 1583100979Srwatson if (error) 1584100979Srwatson mac_destroy_temp(label); 1585100979Srwatson 1586100979Srwatson return (error); 1587100979Srwatson} 1588100979Srwatson 1589100979Srwatson/* 1590100979Srwatson * Initialize MAC label for the first kernel process, from which other 1591100979Srwatson * kernel processes and threads are spawned. 1592100979Srwatson */ 1593100979Srwatsonvoid 1594100979Srwatsonmac_create_proc0(struct ucred *cred) 1595100979Srwatson{ 1596100979Srwatson 1597100979Srwatson MAC_PERFORM(create_proc0, cred); 1598100979Srwatson} 1599100979Srwatson 1600100979Srwatson/* 1601100979Srwatson * Initialize MAC label for the first userland process, from which other 1602100979Srwatson * userland processes and threads are spawned. 1603100979Srwatson */ 1604100979Srwatsonvoid 1605100979Srwatsonmac_create_proc1(struct ucred *cred) 1606100979Srwatson{ 1607100979Srwatson 1608100979Srwatson MAC_PERFORM(create_proc1, cred); 1609100979Srwatson} 1610100979Srwatson 1611104338Srwatsonvoid 1612104338Srwatsonmac_thread_userret(struct thread *td) 1613104338Srwatson{ 1614104338Srwatson 1615104338Srwatson MAC_PERFORM(thread_userret, td); 1616104338Srwatson} 1617104338Srwatson 1618100979Srwatson/* 1619100979Srwatson * When a new process is created, its label must be initialized. Generally, 1620100979Srwatson * this involves inheritence from the parent process, modulo possible 1621100979Srwatson * deltas. This function allows that processing to take place. 1622100979Srwatson */ 1623100979Srwatsonvoid 1624100979Srwatsonmac_create_cred(struct ucred *parent_cred, struct ucred *child_cred) 1625100979Srwatson{ 1626100979Srwatson 1627100979Srwatson MAC_PERFORM(create_cred, parent_cred, child_cred); 1628100979Srwatson} 1629100979Srwatson 1630100979Srwatsonint 1631100979Srwatsonmac_check_vnode_access(struct ucred *cred, struct vnode *vp, int flags) 1632100979Srwatson{ 1633100979Srwatson int error; 1634100979Srwatson 1635100979Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_access"); 1636100979Srwatson 1637100979Srwatson if (!mac_enforce_fs) 1638100979Srwatson return (0); 1639100979Srwatson 1640100979Srwatson error = vn_refreshlabel(vp, cred); 1641100979Srwatson if (error) 1642100979Srwatson return (error); 1643100979Srwatson 1644100979Srwatson MAC_CHECK(check_vnode_access, cred, vp, &vp->v_label, flags); 1645100979Srwatson return (error); 1646100979Srwatson} 1647100979Srwatson 1648100979Srwatsonint 1649100979Srwatsonmac_check_vnode_chdir(struct ucred *cred, struct vnode *dvp) 1650100979Srwatson{ 1651100979Srwatson int error; 1652100979Srwatson 1653100979Srwatson ASSERT_VOP_LOCKED(dvp, "mac_check_vnode_chdir"); 1654100979Srwatson 1655100979Srwatson if (!mac_enforce_fs) 1656100979Srwatson return (0); 1657100979Srwatson 1658100979Srwatson error = vn_refreshlabel(dvp, cred); 1659100979Srwatson if (error) 1660100979Srwatson return (error); 1661100979Srwatson 1662100979Srwatson MAC_CHECK(check_vnode_chdir, cred, dvp, &dvp->v_label); 1663100979Srwatson return (error); 1664100979Srwatson} 1665100979Srwatson 1666100979Srwatsonint 1667100979Srwatsonmac_check_vnode_chroot(struct ucred *cred, struct vnode *dvp) 1668100979Srwatson{ 1669100979Srwatson int error; 1670100979Srwatson 1671100979Srwatson ASSERT_VOP_LOCKED(dvp, "mac_check_vnode_chroot"); 1672100979Srwatson 1673100979Srwatson if (!mac_enforce_fs) 1674100979Srwatson return (0); 1675100979Srwatson 1676100979Srwatson error = vn_refreshlabel(dvp, cred); 1677100979Srwatson if (error) 1678100979Srwatson return (error); 1679100979Srwatson 1680100979Srwatson MAC_CHECK(check_vnode_chroot, cred, dvp, &dvp->v_label); 1681100979Srwatson return (error); 1682100979Srwatson} 1683100979Srwatson 1684100979Srwatsonint 1685100979Srwatsonmac_check_vnode_create(struct ucred *cred, struct vnode *dvp, 1686100979Srwatson struct componentname *cnp, struct vattr *vap) 1687100979Srwatson{ 1688100979Srwatson int error; 1689100979Srwatson 1690100979Srwatson ASSERT_VOP_LOCKED(dvp, "mac_check_vnode_create"); 1691100979Srwatson 1692100979Srwatson if (!mac_enforce_fs) 1693100979Srwatson return (0); 1694100979Srwatson 1695100979Srwatson error = vn_refreshlabel(dvp, cred); 1696100979Srwatson if (error) 1697100979Srwatson return (error); 1698100979Srwatson 1699100979Srwatson MAC_CHECK(check_vnode_create, cred, dvp, &dvp->v_label, cnp, vap); 1700100979Srwatson return (error); 1701100979Srwatson} 1702100979Srwatson 1703100979Srwatsonint 1704100979Srwatsonmac_check_vnode_delete(struct ucred *cred, struct vnode *dvp, struct vnode *vp, 1705100979Srwatson struct componentname *cnp) 1706100979Srwatson{ 1707100979Srwatson int error; 1708100979Srwatson 1709100979Srwatson ASSERT_VOP_LOCKED(dvp, "mac_check_vnode_delete"); 1710100979Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_delete"); 1711100979Srwatson 1712100979Srwatson if (!mac_enforce_fs) 1713100979Srwatson return (0); 1714100979Srwatson 1715100979Srwatson error = vn_refreshlabel(dvp, cred); 1716100979Srwatson if (error) 1717100979Srwatson return (error); 1718100979Srwatson error = vn_refreshlabel(vp, cred); 1719100979Srwatson if (error) 1720100979Srwatson return (error); 1721100979Srwatson 1722100979Srwatson MAC_CHECK(check_vnode_delete, cred, dvp, &dvp->v_label, vp, 1723100979Srwatson &vp->v_label, cnp); 1724100979Srwatson return (error); 1725100979Srwatson} 1726100979Srwatson 1727100979Srwatsonint 1728100979Srwatsonmac_check_vnode_deleteacl(struct ucred *cred, struct vnode *vp, 1729100979Srwatson acl_type_t type) 1730100979Srwatson{ 1731100979Srwatson int error; 1732100979Srwatson 1733100979Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_deleteacl"); 1734100979Srwatson 1735100979Srwatson if (!mac_enforce_fs) 1736100979Srwatson return (0); 1737100979Srwatson 1738100979Srwatson error = vn_refreshlabel(vp, cred); 1739100979Srwatson if (error) 1740100979Srwatson return (error); 1741100979Srwatson 1742100979Srwatson MAC_CHECK(check_vnode_deleteacl, cred, vp, &vp->v_label, type); 1743100979Srwatson return (error); 1744100979Srwatson} 1745100979Srwatson 1746100979Srwatsonint 1747100979Srwatsonmac_check_vnode_exec(struct ucred *cred, struct vnode *vp) 1748100979Srwatson{ 1749100979Srwatson int error; 1750100979Srwatson 1751102102Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_exec"); 1752102102Srwatson 1753100979Srwatson if (!mac_enforce_process && !mac_enforce_fs) 1754100979Srwatson return (0); 1755100979Srwatson 1756100979Srwatson error = vn_refreshlabel(vp, cred); 1757100979Srwatson if (error) 1758100979Srwatson return (error); 1759100979Srwatson MAC_CHECK(check_vnode_exec, cred, vp, &vp->v_label); 1760100979Srwatson 1761100979Srwatson return (error); 1762100979Srwatson} 1763100979Srwatson 1764100979Srwatsonint 1765100979Srwatsonmac_check_vnode_getacl(struct ucred *cred, struct vnode *vp, acl_type_t type) 1766100979Srwatson{ 1767100979Srwatson int error; 1768100979Srwatson 1769100979Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_getacl"); 1770100979Srwatson 1771100979Srwatson if (!mac_enforce_fs) 1772100979Srwatson return (0); 1773100979Srwatson 1774100979Srwatson error = vn_refreshlabel(vp, cred); 1775100979Srwatson if (error) 1776100979Srwatson return (error); 1777100979Srwatson 1778100979Srwatson MAC_CHECK(check_vnode_getacl, cred, vp, &vp->v_label, type); 1779100979Srwatson return (error); 1780100979Srwatson} 1781100979Srwatson 1782100979Srwatsonint 1783100979Srwatsonmac_check_vnode_getextattr(struct ucred *cred, struct vnode *vp, 1784100979Srwatson int attrnamespace, const char *name, struct uio *uio) 1785100979Srwatson{ 1786100979Srwatson int error; 1787100979Srwatson 1788100979Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_getextattr"); 1789100979Srwatson 1790100979Srwatson if (!mac_enforce_fs) 1791100979Srwatson return (0); 1792100979Srwatson 1793100979Srwatson error = vn_refreshlabel(vp, cred); 1794100979Srwatson if (error) 1795100979Srwatson return (error); 1796100979Srwatson 1797100979Srwatson MAC_CHECK(check_vnode_getextattr, cred, vp, &vp->v_label, 1798100979Srwatson attrnamespace, name, uio); 1799100979Srwatson return (error); 1800100979Srwatson} 1801100979Srwatson 1802100979Srwatsonint 1803100979Srwatsonmac_check_vnode_lookup(struct ucred *cred, struct vnode *dvp, 1804100979Srwatson struct componentname *cnp) 1805100979Srwatson{ 1806100979Srwatson int error; 1807100979Srwatson 1808100979Srwatson ASSERT_VOP_LOCKED(dvp, "mac_check_vnode_lookup"); 1809100979Srwatson 1810100979Srwatson if (!mac_enforce_fs) 1811100979Srwatson return (0); 1812100979Srwatson 1813100979Srwatson error = vn_refreshlabel(dvp, cred); 1814100979Srwatson if (error) 1815100979Srwatson return (error); 1816100979Srwatson 1817100979Srwatson MAC_CHECK(check_vnode_lookup, cred, dvp, &dvp->v_label, cnp); 1818100979Srwatson return (error); 1819100979Srwatson} 1820100979Srwatson 1821100979Srwatsonvm_prot_t 1822100979Srwatsonmac_check_vnode_mmap_prot(struct ucred *cred, struct vnode *vp, int newmapping) 1823100979Srwatson{ 1824100979Srwatson vm_prot_t result = VM_PROT_ALL; 1825100979Srwatson 1826103514Srwatson if (!mac_enforce_vm) 1827103514Srwatson return (result); 1828103514Srwatson 1829100979Srwatson /* 1830100979Srwatson * This should be some sort of MAC_BITWISE, maybe :) 1831100979Srwatson */ 1832100979Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_mmap_perms"); 1833100979Srwatson MAC_BOOLEAN(check_vnode_mmap_perms, &, cred, vp, &vp->v_label, 1834100979Srwatson newmapping); 1835100979Srwatson return (result); 1836100979Srwatson} 1837100979Srwatson 1838100979Srwatsonint 1839102112Srwatsonmac_check_vnode_open(struct ucred *cred, struct vnode *vp, mode_t acc_mode) 1840100979Srwatson{ 1841100979Srwatson int error; 1842100979Srwatson 1843102112Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_open"); 1844102112Srwatson 1845100979Srwatson if (!mac_enforce_fs) 1846100979Srwatson return (0); 1847100979Srwatson 1848102112Srwatson error = vn_refreshlabel(vp, cred); 1849102112Srwatson if (error) 1850102112Srwatson return (error); 1851100979Srwatson 1852102112Srwatson MAC_CHECK(check_vnode_open, cred, vp, &vp->v_label, acc_mode); 1853102112Srwatson return (error); 1854102112Srwatson} 1855102112Srwatson 1856102112Srwatsonint 1857102129Srwatsonmac_check_vnode_poll(struct ucred *active_cred, struct ucred *file_cred, 1858102129Srwatson struct vnode *vp) 1859102112Srwatson{ 1860102112Srwatson int error; 1861102112Srwatson 1862102112Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_poll"); 1863102112Srwatson 1864102112Srwatson if (!mac_enforce_fs) 1865102112Srwatson return (0); 1866102112Srwatson 1867102129Srwatson error = vn_refreshlabel(vp, active_cred); 1868100979Srwatson if (error) 1869100979Srwatson return (error); 1870100979Srwatson 1871102129Srwatson MAC_CHECK(check_vnode_poll, active_cred, file_cred, vp, 1872102129Srwatson &vp->v_label); 1873100979Srwatson 1874100979Srwatson return (error); 1875100979Srwatson} 1876100979Srwatson 1877100979Srwatsonint 1878102129Srwatsonmac_check_vnode_read(struct ucred *active_cred, struct ucred *file_cred, 1879102129Srwatson struct vnode *vp) 1880100979Srwatson{ 1881100979Srwatson int error; 1882100979Srwatson 1883102112Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_read"); 1884100979Srwatson 1885100979Srwatson if (!mac_enforce_fs) 1886100979Srwatson return (0); 1887100979Srwatson 1888102129Srwatson error = vn_refreshlabel(vp, active_cred); 1889100979Srwatson if (error) 1890100979Srwatson return (error); 1891100979Srwatson 1892102129Srwatson MAC_CHECK(check_vnode_read, active_cred, file_cred, vp, 1893102129Srwatson &vp->v_label); 1894102112Srwatson 1895100979Srwatson return (error); 1896100979Srwatson} 1897100979Srwatson 1898100979Srwatsonint 1899100979Srwatsonmac_check_vnode_readdir(struct ucred *cred, struct vnode *dvp) 1900100979Srwatson{ 1901100979Srwatson int error; 1902100979Srwatson 1903100979Srwatson ASSERT_VOP_LOCKED(dvp, "mac_check_vnode_readdir"); 1904100979Srwatson 1905100979Srwatson if (!mac_enforce_fs) 1906100979Srwatson return (0); 1907100979Srwatson 1908100979Srwatson error = vn_refreshlabel(dvp, cred); 1909100979Srwatson if (error) 1910100979Srwatson return (error); 1911100979Srwatson 1912100979Srwatson MAC_CHECK(check_vnode_readdir, cred, dvp, &dvp->v_label); 1913100979Srwatson return (error); 1914100979Srwatson} 1915100979Srwatson 1916100979Srwatsonint 1917100979Srwatsonmac_check_vnode_readlink(struct ucred *cred, struct vnode *vp) 1918100979Srwatson{ 1919100979Srwatson int error; 1920100979Srwatson 1921100979Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_readlink"); 1922100979Srwatson 1923100979Srwatson if (!mac_enforce_fs) 1924100979Srwatson return (0); 1925100979Srwatson 1926100979Srwatson error = vn_refreshlabel(vp, cred); 1927100979Srwatson if (error) 1928100979Srwatson return (error); 1929100979Srwatson 1930100979Srwatson MAC_CHECK(check_vnode_readlink, cred, vp, &vp->v_label); 1931100979Srwatson return (error); 1932100979Srwatson} 1933100979Srwatson 1934100979Srwatsonstatic int 1935100979Srwatsonmac_check_vnode_relabel(struct ucred *cred, struct vnode *vp, 1936100979Srwatson struct label *newlabel) 1937100979Srwatson{ 1938100979Srwatson int error; 1939100979Srwatson 1940100979Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_relabel"); 1941100979Srwatson 1942100979Srwatson error = vn_refreshlabel(vp, cred); 1943100979Srwatson if (error) 1944100979Srwatson return (error); 1945100979Srwatson 1946100979Srwatson MAC_CHECK(check_vnode_relabel, cred, vp, &vp->v_label, newlabel); 1947100979Srwatson 1948100979Srwatson return (error); 1949100979Srwatson} 1950100979Srwatson 1951100979Srwatsonint 1952100979Srwatsonmac_check_vnode_rename_from(struct ucred *cred, struct vnode *dvp, 1953100979Srwatson struct vnode *vp, struct componentname *cnp) 1954100979Srwatson{ 1955100979Srwatson int error; 1956100979Srwatson 1957100979Srwatson ASSERT_VOP_LOCKED(dvp, "mac_check_vnode_rename_from"); 1958100979Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_rename_from"); 1959100979Srwatson 1960100979Srwatson if (!mac_enforce_fs) 1961100979Srwatson return (0); 1962100979Srwatson 1963100979Srwatson error = vn_refreshlabel(dvp, cred); 1964100979Srwatson if (error) 1965100979Srwatson return (error); 1966100979Srwatson error = vn_refreshlabel(vp, cred); 1967100979Srwatson if (error) 1968100979Srwatson return (error); 1969100979Srwatson 1970100979Srwatson MAC_CHECK(check_vnode_rename_from, cred, dvp, &dvp->v_label, vp, 1971100979Srwatson &vp->v_label, cnp); 1972100979Srwatson return (error); 1973100979Srwatson} 1974100979Srwatson 1975100979Srwatsonint 1976100979Srwatsonmac_check_vnode_rename_to(struct ucred *cred, struct vnode *dvp, 1977100979Srwatson struct vnode *vp, int samedir, struct componentname *cnp) 1978100979Srwatson{ 1979100979Srwatson int error; 1980100979Srwatson 1981100979Srwatson ASSERT_VOP_LOCKED(dvp, "mac_check_vnode_rename_to"); 1982100979Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_rename_to"); 1983100979Srwatson 1984100979Srwatson if (!mac_enforce_fs) 1985100979Srwatson return (0); 1986100979Srwatson 1987100979Srwatson error = vn_refreshlabel(dvp, cred); 1988100979Srwatson if (error) 1989100979Srwatson return (error); 1990100979Srwatson if (vp != NULL) { 1991100979Srwatson error = vn_refreshlabel(vp, cred); 1992100979Srwatson if (error) 1993100979Srwatson return (error); 1994100979Srwatson } 1995100979Srwatson MAC_CHECK(check_vnode_rename_to, cred, dvp, &dvp->v_label, vp, 1996100979Srwatson vp != NULL ? &vp->v_label : NULL, samedir, cnp); 1997100979Srwatson return (error); 1998100979Srwatson} 1999100979Srwatson 2000100979Srwatsonint 2001100979Srwatsonmac_check_vnode_revoke(struct ucred *cred, struct vnode *vp) 2002100979Srwatson{ 2003100979Srwatson int error; 2004100979Srwatson 2005100979Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_revoke"); 2006100979Srwatson 2007100979Srwatson if (!mac_enforce_fs) 2008100979Srwatson return (0); 2009100979Srwatson 2010100979Srwatson error = vn_refreshlabel(vp, cred); 2011100979Srwatson if (error) 2012100979Srwatson return (error); 2013100979Srwatson 2014100979Srwatson MAC_CHECK(check_vnode_revoke, cred, vp, &vp->v_label); 2015100979Srwatson return (error); 2016100979Srwatson} 2017100979Srwatson 2018100979Srwatsonint 2019100979Srwatsonmac_check_vnode_setacl(struct ucred *cred, struct vnode *vp, acl_type_t type, 2020100979Srwatson struct acl *acl) 2021100979Srwatson{ 2022100979Srwatson int error; 2023100979Srwatson 2024100979Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_setacl"); 2025100979Srwatson 2026100979Srwatson if (!mac_enforce_fs) 2027100979Srwatson return (0); 2028100979Srwatson 2029100979Srwatson error = vn_refreshlabel(vp, cred); 2030100979Srwatson if (error) 2031100979Srwatson return (error); 2032100979Srwatson 2033100979Srwatson MAC_CHECK(check_vnode_setacl, cred, vp, &vp->v_label, type, acl); 2034100979Srwatson return (error); 2035100979Srwatson} 2036100979Srwatson 2037100979Srwatsonint 2038100979Srwatsonmac_check_vnode_setextattr(struct ucred *cred, struct vnode *vp, 2039100979Srwatson int attrnamespace, const char *name, struct uio *uio) 2040100979Srwatson{ 2041100979Srwatson int error; 2042100979Srwatson 2043100979Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_setextattr"); 2044100979Srwatson 2045100979Srwatson if (!mac_enforce_fs) 2046100979Srwatson return (0); 2047100979Srwatson 2048100979Srwatson error = vn_refreshlabel(vp, cred); 2049100979Srwatson if (error) 2050100979Srwatson return (error); 2051100979Srwatson 2052100979Srwatson MAC_CHECK(check_vnode_setextattr, cred, vp, &vp->v_label, 2053100979Srwatson attrnamespace, name, uio); 2054100979Srwatson return (error); 2055100979Srwatson} 2056100979Srwatson 2057100979Srwatsonint 2058100979Srwatsonmac_check_vnode_setflags(struct ucred *cred, struct vnode *vp, u_long flags) 2059100979Srwatson{ 2060100979Srwatson int error; 2061100979Srwatson 2062100979Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_setflags"); 2063100979Srwatson 2064100979Srwatson if (!mac_enforce_fs) 2065100979Srwatson return (0); 2066100979Srwatson 2067100979Srwatson error = vn_refreshlabel(vp, cred); 2068100979Srwatson if (error) 2069100979Srwatson return (error); 2070100979Srwatson 2071100979Srwatson MAC_CHECK(check_vnode_setflags, cred, vp, &vp->v_label, flags); 2072100979Srwatson return (error); 2073100979Srwatson} 2074100979Srwatson 2075100979Srwatsonint 2076100979Srwatsonmac_check_vnode_setmode(struct ucred *cred, struct vnode *vp, mode_t mode) 2077100979Srwatson{ 2078100979Srwatson int error; 2079100979Srwatson 2080100979Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_setmode"); 2081100979Srwatson 2082100979Srwatson if (!mac_enforce_fs) 2083100979Srwatson return (0); 2084100979Srwatson 2085100979Srwatson error = vn_refreshlabel(vp, cred); 2086100979Srwatson if (error) 2087100979Srwatson return (error); 2088100979Srwatson 2089100979Srwatson MAC_CHECK(check_vnode_setmode, cred, vp, &vp->v_label, mode); 2090100979Srwatson return (error); 2091100979Srwatson} 2092100979Srwatson 2093100979Srwatsonint 2094100979Srwatsonmac_check_vnode_setowner(struct ucred *cred, struct vnode *vp, uid_t uid, 2095100979Srwatson gid_t gid) 2096100979Srwatson{ 2097100979Srwatson int error; 2098100979Srwatson 2099100979Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_setowner"); 2100100979Srwatson 2101100979Srwatson if (!mac_enforce_fs) 2102100979Srwatson return (0); 2103100979Srwatson 2104100979Srwatson error = vn_refreshlabel(vp, cred); 2105100979Srwatson if (error) 2106100979Srwatson return (error); 2107100979Srwatson 2108100979Srwatson MAC_CHECK(check_vnode_setowner, cred, vp, &vp->v_label, uid, gid); 2109100979Srwatson return (error); 2110100979Srwatson} 2111100979Srwatson 2112100979Srwatsonint 2113100979Srwatsonmac_check_vnode_setutimes(struct ucred *cred, struct vnode *vp, 2114100979Srwatson struct timespec atime, struct timespec mtime) 2115100979Srwatson{ 2116100979Srwatson int error; 2117100979Srwatson 2118100979Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_setutimes"); 2119100979Srwatson 2120100979Srwatson if (!mac_enforce_fs) 2121100979Srwatson return (0); 2122100979Srwatson 2123100979Srwatson error = vn_refreshlabel(vp, cred); 2124100979Srwatson if (error) 2125100979Srwatson return (error); 2126100979Srwatson 2127100979Srwatson MAC_CHECK(check_vnode_setutimes, cred, vp, &vp->v_label, atime, 2128100979Srwatson mtime); 2129100979Srwatson return (error); 2130100979Srwatson} 2131100979Srwatson 2132100979Srwatsonint 2133102129Srwatsonmac_check_vnode_stat(struct ucred *active_cred, struct ucred *file_cred, 2134102129Srwatson struct vnode *vp) 2135100979Srwatson{ 2136100979Srwatson int error; 2137100979Srwatson 2138100979Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_stat"); 2139100979Srwatson 2140100979Srwatson if (!mac_enforce_fs) 2141100979Srwatson return (0); 2142100979Srwatson 2143102129Srwatson error = vn_refreshlabel(vp, active_cred); 2144100979Srwatson if (error) 2145100979Srwatson return (error); 2146100979Srwatson 2147102129Srwatson MAC_CHECK(check_vnode_stat, active_cred, file_cred, vp, 2148102129Srwatson &vp->v_label); 2149100979Srwatson return (error); 2150100979Srwatson} 2151100979Srwatson 2152102112Srwatsonint 2153102129Srwatsonmac_check_vnode_write(struct ucred *active_cred, struct ucred *file_cred, 2154102129Srwatson struct vnode *vp) 2155102112Srwatson{ 2156102112Srwatson int error; 2157102112Srwatson 2158102112Srwatson ASSERT_VOP_LOCKED(vp, "mac_check_vnode_write"); 2159102112Srwatson 2160102112Srwatson if (!mac_enforce_fs) 2161102112Srwatson return (0); 2162102112Srwatson 2163102129Srwatson error = vn_refreshlabel(vp, active_cred); 2164102112Srwatson if (error) 2165102112Srwatson return (error); 2166102112Srwatson 2167102129Srwatson MAC_CHECK(check_vnode_write, active_cred, file_cred, vp, 2168102129Srwatson &vp->v_label); 2169102112Srwatson 2170102112Srwatson return (error); 2171102112Srwatson} 2172102112Srwatson 2173100979Srwatson/* 2174100979Srwatson * When relabeling a process, call out to the policies for the maximum 2175100979Srwatson * permission allowed for each object type we know about in its 2176100979Srwatson * memory space, and revoke access (in the least surprising ways we 2177100979Srwatson * know) when necessary. The process lock is not held here. 2178100979Srwatson */ 2179100979Srwatsonstatic void 2180100979Srwatsonmac_cred_mmapped_drop_perms(struct thread *td, struct ucred *cred) 2181100979Srwatson{ 2182100979Srwatson 2183100979Srwatson /* XXX freeze all other threads */ 2184100979Srwatson mac_cred_mmapped_drop_perms_recurse(td, cred, 2185100979Srwatson &td->td_proc->p_vmspace->vm_map); 2186100979Srwatson /* XXX allow other threads to continue */ 2187100979Srwatson} 2188100979Srwatson 2189100979Srwatsonstatic __inline const char * 2190100979Srwatsonprot2str(vm_prot_t prot) 2191100979Srwatson{ 2192100979Srwatson 2193100979Srwatson switch (prot & VM_PROT_ALL) { 2194100979Srwatson case VM_PROT_READ: 2195100979Srwatson return ("r--"); 2196100979Srwatson case VM_PROT_READ | VM_PROT_WRITE: 2197100979Srwatson return ("rw-"); 2198100979Srwatson case VM_PROT_READ | VM_PROT_EXECUTE: 2199100979Srwatson return ("r-x"); 2200100979Srwatson case VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE: 2201100979Srwatson return ("rwx"); 2202100979Srwatson case VM_PROT_WRITE: 2203100979Srwatson return ("-w-"); 2204100979Srwatson case VM_PROT_EXECUTE: 2205100979Srwatson return ("--x"); 2206100979Srwatson case VM_PROT_WRITE | VM_PROT_EXECUTE: 2207100979Srwatson return ("-wx"); 2208100979Srwatson default: 2209100979Srwatson return ("---"); 2210100979Srwatson } 2211100979Srwatson} 2212100979Srwatson 2213100979Srwatsonstatic void 2214100979Srwatsonmac_cred_mmapped_drop_perms_recurse(struct thread *td, struct ucred *cred, 2215100979Srwatson struct vm_map *map) 2216100979Srwatson{ 2217100979Srwatson struct vm_map_entry *vme; 2218100979Srwatson vm_prot_t result, revokeperms; 2219100979Srwatson vm_object_t object; 2220100979Srwatson vm_ooffset_t offset; 2221100979Srwatson struct vnode *vp; 2222100979Srwatson 2223103136Srwatson if (!mac_mmap_revocation) 2224103136Srwatson return; 2225103136Srwatson 2226100979Srwatson vm_map_lock_read(map); 2227100979Srwatson for (vme = map->header.next; vme != &map->header; vme = vme->next) { 2228100979Srwatson if (vme->eflags & MAP_ENTRY_IS_SUB_MAP) { 2229100979Srwatson mac_cred_mmapped_drop_perms_recurse(td, cred, 2230100979Srwatson vme->object.sub_map); 2231100979Srwatson continue; 2232100979Srwatson } 2233100979Srwatson /* 2234100979Srwatson * Skip over entries that obviously are not shared. 2235100979Srwatson */ 2236100979Srwatson if (vme->eflags & (MAP_ENTRY_COW | MAP_ENTRY_NOSYNC) || 2237100979Srwatson !vme->max_protection) 2238100979Srwatson continue; 2239100979Srwatson /* 2240100979Srwatson * Drill down to the deepest backing object. 2241100979Srwatson */ 2242100979Srwatson offset = vme->offset; 2243100979Srwatson object = vme->object.vm_object; 2244100979Srwatson if (object == NULL) 2245100979Srwatson continue; 2246100979Srwatson while (object->backing_object != NULL) { 2247100979Srwatson object = object->backing_object; 2248100979Srwatson offset += object->backing_object_offset; 2249100979Srwatson } 2250100979Srwatson /* 2251100979Srwatson * At the moment, vm_maps and objects aren't considered 2252100979Srwatson * by the MAC system, so only things with backing by a 2253100979Srwatson * normal object (read: vnodes) are checked. 2254100979Srwatson */ 2255100979Srwatson if (object->type != OBJT_VNODE) 2256100979Srwatson continue; 2257100979Srwatson vp = (struct vnode *)object->handle; 2258100979Srwatson vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 2259100979Srwatson result = mac_check_vnode_mmap_prot(cred, vp, 0); 2260100979Srwatson VOP_UNLOCK(vp, 0, td); 2261100979Srwatson /* 2262100979Srwatson * Find out what maximum protection we may be allowing 2263100979Srwatson * now but a policy needs to get removed. 2264100979Srwatson */ 2265100979Srwatson revokeperms = vme->max_protection & ~result; 2266100979Srwatson if (!revokeperms) 2267100979Srwatson continue; 2268102949Sbde printf("pid %ld: revoking %s perms from %#lx:%ld " 2269102949Sbde "(max %s/cur %s)\n", (long)td->td_proc->p_pid, 2270102949Sbde prot2str(revokeperms), (u_long)vme->start, 2271102949Sbde (long)(vme->end - vme->start), 2272100979Srwatson prot2str(vme->max_protection), prot2str(vme->protection)); 2273100979Srwatson vm_map_lock_upgrade(map); 2274100979Srwatson /* 2275100979Srwatson * This is the really simple case: if a map has more 2276100979Srwatson * max_protection than is allowed, but it's not being 2277100979Srwatson * actually used (that is, the current protection is 2278100979Srwatson * still allowed), we can just wipe it out and do 2279100979Srwatson * nothing more. 2280100979Srwatson */ 2281100979Srwatson if ((vme->protection & revokeperms) == 0) { 2282100979Srwatson vme->max_protection -= revokeperms; 2283100979Srwatson } else { 2284100979Srwatson if (revokeperms & VM_PROT_WRITE) { 2285100979Srwatson /* 2286100979Srwatson * In the more complicated case, flush out all 2287100979Srwatson * pending changes to the object then turn it 2288100979Srwatson * copy-on-write. 2289100979Srwatson */ 2290100979Srwatson vm_object_reference(object); 2291100979Srwatson vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 2292100979Srwatson vm_object_page_clean(object, 2293100979Srwatson OFF_TO_IDX(offset), 2294100979Srwatson OFF_TO_IDX(offset + vme->end - vme->start + 2295100979Srwatson PAGE_MASK), 2296100979Srwatson OBJPC_SYNC); 2297100979Srwatson VOP_UNLOCK(vp, 0, td); 2298100979Srwatson vm_object_deallocate(object); 2299100979Srwatson /* 2300100979Srwatson * Why bother if there's no read permissions 2301100979Srwatson * anymore? For the rest, we need to leave 2302100979Srwatson * the write permissions on for COW, or 2303100979Srwatson * remove them entirely if configured to. 2304100979Srwatson */ 2305100979Srwatson if (!mac_mmap_revocation_via_cow) { 2306100979Srwatson vme->max_protection &= ~VM_PROT_WRITE; 2307100979Srwatson vme->protection &= ~VM_PROT_WRITE; 2308100979Srwatson } if ((revokeperms & VM_PROT_READ) == 0) 2309100979Srwatson vme->eflags |= MAP_ENTRY_COW | 2310100979Srwatson MAP_ENTRY_NEEDS_COPY; 2311100979Srwatson } 2312100979Srwatson if (revokeperms & VM_PROT_EXECUTE) { 2313100979Srwatson vme->max_protection &= ~VM_PROT_EXECUTE; 2314100979Srwatson vme->protection &= ~VM_PROT_EXECUTE; 2315100979Srwatson } 2316100979Srwatson if (revokeperms & VM_PROT_READ) { 2317100979Srwatson vme->max_protection = 0; 2318100979Srwatson vme->protection = 0; 2319100979Srwatson } 2320100979Srwatson pmap_protect(map->pmap, vme->start, vme->end, 2321100979Srwatson vme->protection & ~revokeperms); 2322100979Srwatson vm_map_simplify_entry(map, vme); 2323100979Srwatson } 2324100979Srwatson vm_map_lock_downgrade(map); 2325100979Srwatson } 2326100979Srwatson vm_map_unlock_read(map); 2327100979Srwatson} 2328100979Srwatson 2329100979Srwatson/* 2330100979Srwatson * When the subject's label changes, it may require revocation of privilege 2331100979Srwatson * to mapped objects. This can't be done on-the-fly later with a unified 2332100979Srwatson * buffer cache. 2333100979Srwatson */ 2334100979Srwatsonstatic void 2335100979Srwatsonmac_relabel_cred(struct ucred *cred, struct label *newlabel) 2336100979Srwatson{ 2337100979Srwatson 2338100979Srwatson MAC_PERFORM(relabel_cred, cred, newlabel); 2339100979Srwatson} 2340100979Srwatson 2341100979Srwatsonvoid 2342100979Srwatsonmac_relabel_vnode(struct ucred *cred, struct vnode *vp, struct label *newlabel) 2343100979Srwatson{ 2344100979Srwatson 2345100979Srwatson MAC_PERFORM(relabel_vnode, cred, vp, &vp->v_label, newlabel); 2346100979Srwatson} 2347100979Srwatson 2348100979Srwatsonvoid 2349100979Srwatsonmac_create_ifnet(struct ifnet *ifnet) 2350100979Srwatson{ 2351100979Srwatson 2352100979Srwatson MAC_PERFORM(create_ifnet, ifnet, &ifnet->if_label); 2353100979Srwatson} 2354100979Srwatson 2355100979Srwatsonvoid 2356100979Srwatsonmac_create_bpfdesc(struct ucred *cred, struct bpf_d *bpf_d) 2357100979Srwatson{ 2358100979Srwatson 2359100979Srwatson MAC_PERFORM(create_bpfdesc, cred, bpf_d, &bpf_d->bd_label); 2360100979Srwatson} 2361100979Srwatson 2362100979Srwatsonvoid 2363100979Srwatsonmac_create_socket(struct ucred *cred, struct socket *socket) 2364100979Srwatson{ 2365100979Srwatson 2366100979Srwatson MAC_PERFORM(create_socket, cred, socket, &socket->so_label); 2367100979Srwatson} 2368100979Srwatson 2369100979Srwatsonvoid 2370100979Srwatsonmac_create_pipe(struct ucred *cred, struct pipe *pipe) 2371100979Srwatson{ 2372100979Srwatson 2373100979Srwatson MAC_PERFORM(create_pipe, cred, pipe, pipe->pipe_label); 2374100979Srwatson} 2375100979Srwatson 2376100979Srwatsonvoid 2377100979Srwatsonmac_create_socket_from_socket(struct socket *oldsocket, 2378100979Srwatson struct socket *newsocket) 2379100979Srwatson{ 2380100979Srwatson 2381100979Srwatson MAC_PERFORM(create_socket_from_socket, oldsocket, &oldsocket->so_label, 2382100979Srwatson newsocket, &newsocket->so_label); 2383100979Srwatson} 2384100979Srwatson 2385100979Srwatsonstatic void 2386100979Srwatsonmac_relabel_socket(struct ucred *cred, struct socket *socket, 2387100979Srwatson struct label *newlabel) 2388100979Srwatson{ 2389100979Srwatson 2390100979Srwatson MAC_PERFORM(relabel_socket, cred, socket, &socket->so_label, newlabel); 2391100979Srwatson} 2392100979Srwatson 2393100979Srwatsonstatic void 2394100979Srwatsonmac_relabel_pipe(struct ucred *cred, struct pipe *pipe, struct label *newlabel) 2395100979Srwatson{ 2396100979Srwatson 2397100979Srwatson MAC_PERFORM(relabel_pipe, cred, pipe, pipe->pipe_label, newlabel); 2398100979Srwatson} 2399100979Srwatson 2400100979Srwatsonvoid 2401100979Srwatsonmac_set_socket_peer_from_mbuf(struct mbuf *mbuf, struct socket *socket) 2402100979Srwatson{ 2403100979Srwatson 2404100979Srwatson MAC_PERFORM(set_socket_peer_from_mbuf, mbuf, &mbuf->m_pkthdr.label, 2405100979Srwatson socket, &socket->so_peerlabel); 2406100979Srwatson} 2407100979Srwatson 2408100979Srwatsonvoid 2409100979Srwatsonmac_set_socket_peer_from_socket(struct socket *oldsocket, 2410100979Srwatson struct socket *newsocket) 2411100979Srwatson{ 2412100979Srwatson 2413100979Srwatson MAC_PERFORM(set_socket_peer_from_socket, oldsocket, 2414100979Srwatson &oldsocket->so_label, newsocket, &newsocket->so_peerlabel); 2415100979Srwatson} 2416100979Srwatson 2417100979Srwatsonvoid 2418100979Srwatsonmac_create_datagram_from_ipq(struct ipq *ipq, struct mbuf *datagram) 2419100979Srwatson{ 2420100979Srwatson 2421100979Srwatson MAC_PERFORM(create_datagram_from_ipq, ipq, &ipq->ipq_label, 2422100979Srwatson datagram, &datagram->m_pkthdr.label); 2423100979Srwatson} 2424100979Srwatson 2425100979Srwatsonvoid 2426100979Srwatsonmac_create_fragment(struct mbuf *datagram, struct mbuf *fragment) 2427100979Srwatson{ 2428100979Srwatson 2429100979Srwatson MAC_PERFORM(create_fragment, datagram, &datagram->m_pkthdr.label, 2430100979Srwatson fragment, &fragment->m_pkthdr.label); 2431100979Srwatson} 2432100979Srwatson 2433100979Srwatsonvoid 2434100979Srwatsonmac_create_ipq(struct mbuf *fragment, struct ipq *ipq) 2435100979Srwatson{ 2436100979Srwatson 2437100979Srwatson MAC_PERFORM(create_ipq, fragment, &fragment->m_pkthdr.label, ipq, 2438100979Srwatson &ipq->ipq_label); 2439100979Srwatson} 2440100979Srwatson 2441100979Srwatsonvoid 2442100979Srwatsonmac_create_mbuf_from_mbuf(struct mbuf *oldmbuf, struct mbuf *newmbuf) 2443100979Srwatson{ 2444100979Srwatson 2445100979Srwatson MAC_PERFORM(create_mbuf_from_mbuf, oldmbuf, &oldmbuf->m_pkthdr.label, 2446100979Srwatson newmbuf, &newmbuf->m_pkthdr.label); 2447100979Srwatson} 2448100979Srwatson 2449100979Srwatsonvoid 2450100979Srwatsonmac_create_mbuf_from_bpfdesc(struct bpf_d *bpf_d, struct mbuf *mbuf) 2451100979Srwatson{ 2452100979Srwatson 2453100979Srwatson MAC_PERFORM(create_mbuf_from_bpfdesc, bpf_d, &bpf_d->bd_label, mbuf, 2454100979Srwatson &mbuf->m_pkthdr.label); 2455100979Srwatson} 2456100979Srwatson 2457100979Srwatsonvoid 2458100979Srwatsonmac_create_mbuf_linklayer(struct ifnet *ifnet, struct mbuf *mbuf) 2459100979Srwatson{ 2460100979Srwatson 2461100979Srwatson MAC_PERFORM(create_mbuf_linklayer, ifnet, &ifnet->if_label, mbuf, 2462100979Srwatson &mbuf->m_pkthdr.label); 2463100979Srwatson} 2464100979Srwatson 2465100979Srwatsonvoid 2466100979Srwatsonmac_create_mbuf_from_ifnet(struct ifnet *ifnet, struct mbuf *mbuf) 2467100979Srwatson{ 2468100979Srwatson 2469100979Srwatson MAC_PERFORM(create_mbuf_from_ifnet, ifnet, &ifnet->if_label, mbuf, 2470100979Srwatson &mbuf->m_pkthdr.label); 2471100979Srwatson} 2472100979Srwatson 2473100979Srwatsonvoid 2474100979Srwatsonmac_create_mbuf_multicast_encap(struct mbuf *oldmbuf, struct ifnet *ifnet, 2475100979Srwatson struct mbuf *newmbuf) 2476100979Srwatson{ 2477100979Srwatson 2478100979Srwatson MAC_PERFORM(create_mbuf_multicast_encap, oldmbuf, 2479100979Srwatson &oldmbuf->m_pkthdr.label, ifnet, &ifnet->if_label, newmbuf, 2480100979Srwatson &newmbuf->m_pkthdr.label); 2481100979Srwatson} 2482100979Srwatson 2483100979Srwatsonvoid 2484100979Srwatsonmac_create_mbuf_netlayer(struct mbuf *oldmbuf, struct mbuf *newmbuf) 2485100979Srwatson{ 2486100979Srwatson 2487100979Srwatson MAC_PERFORM(create_mbuf_netlayer, oldmbuf, &oldmbuf->m_pkthdr.label, 2488100979Srwatson newmbuf, &newmbuf->m_pkthdr.label); 2489100979Srwatson} 2490100979Srwatson 2491100979Srwatsonint 2492100979Srwatsonmac_fragment_match(struct mbuf *fragment, struct ipq *ipq) 2493100979Srwatson{ 2494100979Srwatson int result; 2495100979Srwatson 2496100979Srwatson result = 1; 2497100979Srwatson MAC_BOOLEAN(fragment_match, &&, fragment, &fragment->m_pkthdr.label, 2498100979Srwatson ipq, &ipq->ipq_label); 2499100979Srwatson 2500100979Srwatson return (result); 2501100979Srwatson} 2502100979Srwatson 2503100979Srwatsonvoid 2504100979Srwatsonmac_update_ipq(struct mbuf *fragment, struct ipq *ipq) 2505100979Srwatson{ 2506100979Srwatson 2507100979Srwatson MAC_PERFORM(update_ipq, fragment, &fragment->m_pkthdr.label, ipq, 2508100979Srwatson &ipq->ipq_label); 2509100979Srwatson} 2510100979Srwatson 2511100979Srwatsonvoid 2512100979Srwatsonmac_create_mbuf_from_socket(struct socket *socket, struct mbuf *mbuf) 2513100979Srwatson{ 2514100979Srwatson 2515100979Srwatson MAC_PERFORM(create_mbuf_from_socket, socket, &socket->so_label, mbuf, 2516100979Srwatson &mbuf->m_pkthdr.label); 2517100979Srwatson} 2518100979Srwatson 2519100979Srwatsonvoid 2520100979Srwatsonmac_create_mount(struct ucred *cred, struct mount *mp) 2521100979Srwatson{ 2522100979Srwatson 2523100979Srwatson MAC_PERFORM(create_mount, cred, mp, &mp->mnt_mntlabel, 2524100979Srwatson &mp->mnt_fslabel); 2525100979Srwatson} 2526100979Srwatson 2527100979Srwatsonvoid 2528100979Srwatsonmac_create_root_mount(struct ucred *cred, struct mount *mp) 2529100979Srwatson{ 2530100979Srwatson 2531100979Srwatson MAC_PERFORM(create_root_mount, cred, mp, &mp->mnt_mntlabel, 2532100979Srwatson &mp->mnt_fslabel); 2533100979Srwatson} 2534100979Srwatson 2535100979Srwatsonint 2536100979Srwatsonmac_check_bpfdesc_receive(struct bpf_d *bpf_d, struct ifnet *ifnet) 2537100979Srwatson{ 2538100979Srwatson int error; 2539100979Srwatson 2540100979Srwatson if (!mac_enforce_network) 2541100979Srwatson return (0); 2542100979Srwatson 2543100979Srwatson MAC_CHECK(check_bpfdesc_receive, bpf_d, &bpf_d->bd_label, ifnet, 2544100979Srwatson &ifnet->if_label); 2545100979Srwatson 2546100979Srwatson return (error); 2547100979Srwatson} 2548100979Srwatson 2549100979Srwatsonstatic int 2550100979Srwatsonmac_check_cred_relabel(struct ucred *cred, struct label *newlabel) 2551100979Srwatson{ 2552100979Srwatson int error; 2553100979Srwatson 2554100979Srwatson MAC_CHECK(check_cred_relabel, cred, newlabel); 2555100979Srwatson 2556100979Srwatson return (error); 2557100979Srwatson} 2558100979Srwatson 2559100979Srwatsonint 2560100979Srwatsonmac_check_cred_visible(struct ucred *u1, struct ucred *u2) 2561100979Srwatson{ 2562100979Srwatson int error; 2563100979Srwatson 2564100979Srwatson if (!mac_enforce_process) 2565100979Srwatson return (0); 2566100979Srwatson 2567100979Srwatson MAC_CHECK(check_cred_visible, u1, u2); 2568100979Srwatson 2569100979Srwatson return (error); 2570100979Srwatson} 2571100979Srwatson 2572100979Srwatsonint 2573100979Srwatsonmac_check_ifnet_transmit(struct ifnet *ifnet, struct mbuf *mbuf) 2574100979Srwatson{ 2575100979Srwatson int error; 2576100979Srwatson 2577100979Srwatson if (!mac_enforce_network) 2578100979Srwatson return (0); 2579100979Srwatson 2580100979Srwatson KASSERT(mbuf->m_flags & M_PKTHDR, ("packet has no pkthdr")); 2581100979Srwatson if (!(mbuf->m_pkthdr.label.l_flags & MAC_FLAG_INITIALIZED)) 2582100979Srwatson printf("%s%d: not initialized\n", ifnet->if_name, 2583100979Srwatson ifnet->if_unit); 2584100979Srwatson 2585100979Srwatson MAC_CHECK(check_ifnet_transmit, ifnet, &ifnet->if_label, mbuf, 2586100979Srwatson &mbuf->m_pkthdr.label); 2587100979Srwatson 2588100979Srwatson return (error); 2589100979Srwatson} 2590100979Srwatson 2591100979Srwatsonint 2592100979Srwatsonmac_check_mount_stat(struct ucred *cred, struct mount *mount) 2593100979Srwatson{ 2594100979Srwatson int error; 2595100979Srwatson 2596100979Srwatson if (!mac_enforce_fs) 2597100979Srwatson return (0); 2598100979Srwatson 2599100979Srwatson MAC_CHECK(check_mount_stat, cred, mount, &mount->mnt_mntlabel); 2600100979Srwatson 2601100979Srwatson return (error); 2602100979Srwatson} 2603100979Srwatson 2604100979Srwatsonint 2605100979Srwatsonmac_check_pipe_ioctl(struct ucred *cred, struct pipe *pipe, unsigned long cmd, 2606100979Srwatson void *data) 2607100979Srwatson{ 2608100979Srwatson int error; 2609100979Srwatson 2610104269Srwatson PIPE_LOCK_ASSERT(pipe, MA_OWNED); 2611104269Srwatson 2612104269Srwatson if (!mac_enforce_pipe) 2613104269Srwatson return (0); 2614104269Srwatson 2615100979Srwatson MAC_CHECK(check_pipe_ioctl, cred, pipe, pipe->pipe_label, cmd, data); 2616100979Srwatson 2617100979Srwatson return (error); 2618100979Srwatson} 2619100979Srwatson 2620100979Srwatsonint 2621102115Srwatsonmac_check_pipe_poll(struct ucred *cred, struct pipe *pipe) 2622100979Srwatson{ 2623100979Srwatson int error; 2624100979Srwatson 2625104269Srwatson PIPE_LOCK_ASSERT(pipe, MA_OWNED); 2626104269Srwatson 2627104269Srwatson if (!mac_enforce_pipe) 2628104269Srwatson return (0); 2629104269Srwatson 2630102115Srwatson MAC_CHECK(check_pipe_poll, cred, pipe, pipe->pipe_label); 2631100979Srwatson 2632100979Srwatson return (error); 2633100979Srwatson} 2634100979Srwatson 2635102115Srwatsonint 2636102115Srwatsonmac_check_pipe_read(struct ucred *cred, struct pipe *pipe) 2637102115Srwatson{ 2638102115Srwatson int error; 2639102115Srwatson 2640104269Srwatson PIPE_LOCK_ASSERT(pipe, MA_OWNED); 2641104269Srwatson 2642104269Srwatson if (!mac_enforce_pipe) 2643104269Srwatson return (0); 2644104269Srwatson 2645102115Srwatson MAC_CHECK(check_pipe_read, cred, pipe, pipe->pipe_label); 2646102115Srwatson 2647102115Srwatson return (error); 2648102115Srwatson} 2649102115Srwatson 2650100979Srwatsonstatic int 2651100979Srwatsonmac_check_pipe_relabel(struct ucred *cred, struct pipe *pipe, 2652100979Srwatson struct label *newlabel) 2653100979Srwatson{ 2654100979Srwatson int error; 2655100979Srwatson 2656104269Srwatson PIPE_LOCK_ASSERT(pipe, MA_OWNED); 2657104269Srwatson 2658104269Srwatson if (!mac_enforce_pipe) 2659104269Srwatson return (0); 2660104269Srwatson 2661100979Srwatson MAC_CHECK(check_pipe_relabel, cred, pipe, pipe->pipe_label, newlabel); 2662100979Srwatson 2663100979Srwatson return (error); 2664100979Srwatson} 2665100979Srwatson 2666100979Srwatsonint 2667102115Srwatsonmac_check_pipe_stat(struct ucred *cred, struct pipe *pipe) 2668102115Srwatson{ 2669102115Srwatson int error; 2670102115Srwatson 2671104269Srwatson PIPE_LOCK_ASSERT(pipe, MA_OWNED); 2672104269Srwatson 2673104269Srwatson if (!mac_enforce_pipe) 2674104269Srwatson return (0); 2675104269Srwatson 2676102115Srwatson MAC_CHECK(check_pipe_stat, cred, pipe, pipe->pipe_label); 2677102115Srwatson 2678102115Srwatson return (error); 2679102115Srwatson} 2680102115Srwatson 2681102115Srwatsonint 2682102115Srwatsonmac_check_pipe_write(struct ucred *cred, struct pipe *pipe) 2683102115Srwatson{ 2684102115Srwatson int error; 2685102115Srwatson 2686104269Srwatson PIPE_LOCK_ASSERT(pipe, MA_OWNED); 2687104269Srwatson 2688104269Srwatson if (!mac_enforce_pipe) 2689104269Srwatson return (0); 2690104269Srwatson 2691102115Srwatson MAC_CHECK(check_pipe_write, cred, pipe, pipe->pipe_label); 2692102115Srwatson 2693102115Srwatson return (error); 2694102115Srwatson} 2695102115Srwatson 2696102115Srwatsonint 2697100979Srwatsonmac_check_proc_debug(struct ucred *cred, struct proc *proc) 2698100979Srwatson{ 2699100979Srwatson int error; 2700100979Srwatson 2701102103Srwatson PROC_LOCK_ASSERT(proc, MA_OWNED); 2702102103Srwatson 2703100979Srwatson if (!mac_enforce_process) 2704100979Srwatson return (0); 2705100979Srwatson 2706100979Srwatson MAC_CHECK(check_proc_debug, cred, proc); 2707100979Srwatson 2708100979Srwatson return (error); 2709100979Srwatson} 2710100979Srwatson 2711100979Srwatsonint 2712100979Srwatsonmac_check_proc_sched(struct ucred *cred, struct proc *proc) 2713100979Srwatson{ 2714100979Srwatson int error; 2715100979Srwatson 2716102103Srwatson PROC_LOCK_ASSERT(proc, MA_OWNED); 2717102103Srwatson 2718100979Srwatson if (!mac_enforce_process) 2719100979Srwatson return (0); 2720100979Srwatson 2721100979Srwatson MAC_CHECK(check_proc_sched, cred, proc); 2722100979Srwatson 2723100979Srwatson return (error); 2724100979Srwatson} 2725100979Srwatson 2726100979Srwatsonint 2727100979Srwatsonmac_check_proc_signal(struct ucred *cred, struct proc *proc, int signum) 2728100979Srwatson{ 2729100979Srwatson int error; 2730100979Srwatson 2731102103Srwatson PROC_LOCK_ASSERT(proc, MA_OWNED); 2732102103Srwatson 2733100979Srwatson if (!mac_enforce_process) 2734100979Srwatson return (0); 2735100979Srwatson 2736100979Srwatson MAC_CHECK(check_proc_signal, cred, proc, signum); 2737100979Srwatson 2738100979Srwatson return (error); 2739100979Srwatson} 2740100979Srwatson 2741100979Srwatsonint 2742100979Srwatsonmac_check_socket_bind(struct ucred *ucred, struct socket *socket, 2743100979Srwatson struct sockaddr *sockaddr) 2744100979Srwatson{ 2745100979Srwatson int error; 2746100979Srwatson 2747100979Srwatson if (!mac_enforce_socket) 2748100979Srwatson return (0); 2749100979Srwatson 2750100979Srwatson MAC_CHECK(check_socket_bind, ucred, socket, &socket->so_label, 2751100979Srwatson sockaddr); 2752100979Srwatson 2753100979Srwatson return (error); 2754100979Srwatson} 2755100979Srwatson 2756100979Srwatsonint 2757100979Srwatsonmac_check_socket_connect(struct ucred *cred, struct socket *socket, 2758100979Srwatson struct sockaddr *sockaddr) 2759100979Srwatson{ 2760100979Srwatson int error; 2761100979Srwatson 2762100979Srwatson if (!mac_enforce_socket) 2763100979Srwatson return (0); 2764100979Srwatson 2765100979Srwatson MAC_CHECK(check_socket_connect, cred, socket, &socket->so_label, 2766100979Srwatson sockaddr); 2767100979Srwatson 2768100979Srwatson return (error); 2769100979Srwatson} 2770100979Srwatson 2771100979Srwatsonint 2772101933Srwatsonmac_check_socket_deliver(struct socket *socket, struct mbuf *mbuf) 2773100979Srwatson{ 2774100979Srwatson int error; 2775100979Srwatson 2776100979Srwatson if (!mac_enforce_socket) 2777100979Srwatson return (0); 2778100979Srwatson 2779101933Srwatson MAC_CHECK(check_socket_deliver, socket, &socket->so_label, mbuf, 2780101933Srwatson &mbuf->m_pkthdr.label); 2781101933Srwatson 2782100979Srwatson return (error); 2783100979Srwatson} 2784100979Srwatson 2785100979Srwatsonint 2786101933Srwatsonmac_check_socket_listen(struct ucred *cred, struct socket *socket) 2787100979Srwatson{ 2788100979Srwatson int error; 2789100979Srwatson 2790100979Srwatson if (!mac_enforce_socket) 2791100979Srwatson return (0); 2792100979Srwatson 2793101933Srwatson MAC_CHECK(check_socket_listen, cred, socket, &socket->so_label); 2794100979Srwatson return (error); 2795100979Srwatson} 2796100979Srwatson 2797100979Srwatsonstatic int 2798100979Srwatsonmac_check_socket_relabel(struct ucred *cred, struct socket *socket, 2799100979Srwatson struct label *newlabel) 2800100979Srwatson{ 2801100979Srwatson int error; 2802100979Srwatson 2803100979Srwatson MAC_CHECK(check_socket_relabel, cred, socket, &socket->so_label, 2804100979Srwatson newlabel); 2805100979Srwatson 2806100979Srwatson return (error); 2807100979Srwatson} 2808100979Srwatson 2809100979Srwatsonint 2810100979Srwatsonmac_check_socket_visible(struct ucred *cred, struct socket *socket) 2811100979Srwatson{ 2812100979Srwatson int error; 2813100979Srwatson 2814100979Srwatson if (!mac_enforce_socket) 2815100979Srwatson return (0); 2816100979Srwatson 2817100979Srwatson MAC_CHECK(check_socket_visible, cred, socket, &socket->so_label); 2818100979Srwatson 2819100979Srwatson return (error); 2820100979Srwatson} 2821100979Srwatson 2822100979Srwatsonint 2823100979Srwatsonmac_ioctl_ifnet_get(struct ucred *cred, struct ifreq *ifr, 2824100979Srwatson struct ifnet *ifnet) 2825100979Srwatson{ 2826100979Srwatson struct mac label; 2827100979Srwatson int error; 2828100979Srwatson 2829100979Srwatson error = mac_externalize(&ifnet->if_label, &label); 2830100979Srwatson if (error) 2831100979Srwatson return (error); 2832100979Srwatson 2833100979Srwatson return (copyout(&label, ifr->ifr_ifru.ifru_data, sizeof(label))); 2834100979Srwatson} 2835100979Srwatson 2836100979Srwatsonint 2837100979Srwatsonmac_ioctl_ifnet_set(struct ucred *cred, struct ifreq *ifr, 2838100979Srwatson struct ifnet *ifnet) 2839100979Srwatson{ 2840100979Srwatson struct mac newlabel; 2841100979Srwatson struct label intlabel; 2842100979Srwatson int error; 2843100979Srwatson 2844100979Srwatson error = copyin(ifr->ifr_ifru.ifru_data, &newlabel, sizeof(newlabel)); 2845100979Srwatson if (error) 2846100979Srwatson return (error); 2847100979Srwatson 2848100979Srwatson error = mac_internalize(&intlabel, &newlabel); 2849100979Srwatson if (error) 2850100979Srwatson return (error); 2851100979Srwatson 2852100979Srwatson /* 2853100979Srwatson * XXX: Note that this is a redundant privilege check, since 2854100979Srwatson * policies impose this check themselves if required by the 2855100979Srwatson * policy. Eventually, this should go away. 2856100979Srwatson */ 2857100979Srwatson error = suser_cred(cred, 0); 2858100979Srwatson if (error) 2859100979Srwatson goto out; 2860100979Srwatson 2861100979Srwatson MAC_CHECK(check_ifnet_relabel, cred, ifnet, &ifnet->if_label, 2862100979Srwatson &intlabel); 2863100979Srwatson if (error) 2864100979Srwatson goto out; 2865100979Srwatson 2866100979Srwatson MAC_PERFORM(relabel_ifnet, cred, ifnet, &ifnet->if_label, &intlabel); 2867100979Srwatson 2868100979Srwatsonout: 2869100979Srwatson mac_destroy_temp(&intlabel); 2870100979Srwatson return (error); 2871100979Srwatson} 2872100979Srwatson 2873100979Srwatsonvoid 2874100979Srwatsonmac_create_devfs_vnode(struct devfs_dirent *de, struct vnode *vp) 2875100979Srwatson{ 2876100979Srwatson 2877100979Srwatson MAC_PERFORM(create_devfs_vnode, de, &de->de_label, vp, &vp->v_label); 2878100979Srwatson} 2879100979Srwatson 2880100979Srwatsonvoid 2881100979Srwatsonmac_create_devfs_device(dev_t dev, struct devfs_dirent *de) 2882100979Srwatson{ 2883100979Srwatson 2884100979Srwatson MAC_PERFORM(create_devfs_device, dev, de, &de->de_label); 2885100979Srwatson} 2886100979Srwatson 2887100979Srwatsonstatic int 2888100979Srwatsonmac_stdcreatevnode_ea(struct vnode *vp) 2889100979Srwatson{ 2890100979Srwatson int error; 2891100979Srwatson 2892100979Srwatson MAC_CHECK(stdcreatevnode_ea, vp, &vp->v_label); 2893100979Srwatson 2894100979Srwatson return (error); 2895100979Srwatson} 2896100979Srwatson 2897100979Srwatsonvoid 2898100979Srwatsonmac_create_devfs_directory(char *dirname, int dirnamelen, 2899100979Srwatson struct devfs_dirent *de) 2900100979Srwatson{ 2901100979Srwatson 2902100979Srwatson MAC_PERFORM(create_devfs_directory, dirname, dirnamelen, de, 2903100979Srwatson &de->de_label); 2904100979Srwatson} 2905100979Srwatson 2906100979Srwatson/* 2907100979Srwatson * When a new vnode is created, this call will initialize its label. 2908100979Srwatson */ 2909100979Srwatsonvoid 2910100979Srwatsonmac_create_vnode(struct ucred *cred, struct vnode *parent, 2911100979Srwatson struct vnode *child) 2912100979Srwatson{ 2913100979Srwatson int error; 2914100979Srwatson 2915100979Srwatson ASSERT_VOP_LOCKED(parent, "mac_create_vnode"); 2916100979Srwatson ASSERT_VOP_LOCKED(child, "mac_create_vnode"); 2917100979Srwatson 2918100979Srwatson error = vn_refreshlabel(parent, cred); 2919100979Srwatson if (error) { 2920100979Srwatson printf("mac_create_vnode: vn_refreshlabel returned %d\n", 2921100979Srwatson error); 2922100979Srwatson printf("mac_create_vnode: using old vnode label\n"); 2923100979Srwatson } 2924100979Srwatson 2925100979Srwatson MAC_PERFORM(create_vnode, cred, parent, &parent->v_label, child, 2926100979Srwatson &child->v_label); 2927100979Srwatson} 2928100979Srwatson 2929100979Srwatsonint 2930100979Srwatsonmac_setsockopt_label_set(struct ucred *cred, struct socket *so, 2931100979Srwatson struct mac *extmac) 2932100979Srwatson{ 2933100979Srwatson struct label intlabel; 2934100979Srwatson int error; 2935100979Srwatson 2936100979Srwatson error = mac_internalize(&intlabel, extmac); 2937100979Srwatson if (error) 2938100979Srwatson return (error); 2939100979Srwatson 2940100979Srwatson mac_check_socket_relabel(cred, so, &intlabel); 2941100979Srwatson if (error) { 2942100979Srwatson mac_destroy_temp(&intlabel); 2943100979Srwatson return (error); 2944100979Srwatson } 2945100979Srwatson 2946100979Srwatson mac_relabel_socket(cred, so, &intlabel); 2947100979Srwatson 2948100979Srwatson mac_destroy_temp(&intlabel); 2949100979Srwatson return (0); 2950100979Srwatson} 2951100979Srwatson 2952100979Srwatsonint 2953100979Srwatsonmac_pipe_label_set(struct ucred *cred, struct pipe *pipe, struct label *label) 2954100979Srwatson{ 2955100979Srwatson int error; 2956100979Srwatson 2957104269Srwatson PIPE_LOCK_ASSERT(pipe, MA_OWNED); 2958104269Srwatson 2959100979Srwatson error = mac_check_pipe_relabel(cred, pipe, label); 2960100979Srwatson if (error) 2961100979Srwatson return (error); 2962100979Srwatson 2963100979Srwatson mac_relabel_pipe(cred, pipe, label); 2964100979Srwatson 2965100979Srwatson return (0); 2966100979Srwatson} 2967100979Srwatson 2968100979Srwatsonint 2969100979Srwatsonmac_getsockopt_label_get(struct ucred *cred, struct socket *so, 2970100979Srwatson struct mac *extmac) 2971100979Srwatson{ 2972100979Srwatson 2973100979Srwatson return (mac_externalize(&so->so_label, extmac)); 2974100979Srwatson} 2975100979Srwatson 2976100979Srwatsonint 2977100979Srwatsonmac_getsockopt_peerlabel_get(struct ucred *cred, struct socket *so, 2978100979Srwatson struct mac *extmac) 2979100979Srwatson{ 2980100979Srwatson 2981100979Srwatson return (mac_externalize(&so->so_peerlabel, extmac)); 2982100979Srwatson} 2983100979Srwatson 2984100979Srwatson/* 2985100979Srwatson * Implementation of VOP_SETLABEL() that relies on extended attributes 2986100979Srwatson * to store label data. Can be referenced by filesystems supporting 2987100979Srwatson * extended attributes. 2988100979Srwatson */ 2989100979Srwatsonint 2990100979Srwatsonvop_stdsetlabel_ea(struct vop_setlabel_args *ap) 2991100979Srwatson{ 2992100979Srwatson struct vnode *vp = ap->a_vp; 2993100979Srwatson struct label *intlabel = ap->a_label; 2994100979Srwatson struct mac extmac; 2995100979Srwatson int error; 2996100979Srwatson 2997100979Srwatson ASSERT_VOP_LOCKED(vp, "vop_stdsetlabel_ea"); 2998100979Srwatson 2999100979Srwatson /* 3000100979Srwatson * XXX: Eventually call out to EA check/set calls here. 3001100979Srwatson * Be particularly careful to avoid race conditions, 3002100979Srwatson * consistency problems, and stability problems when 3003100979Srwatson * dealing with multiple EAs. In particular, we require 3004100979Srwatson * the ability to write multiple EAs on the same file in 3005100979Srwatson * a single transaction, which the current EA interface 3006100979Srwatson * does not provide. 3007100979Srwatson */ 3008100979Srwatson 3009100979Srwatson error = mac_externalize(intlabel, &extmac); 3010100979Srwatson if (error) 3011100979Srwatson return (error); 3012100979Srwatson 3013100979Srwatson error = vn_extattr_set(vp, IO_NODELOCKED, 3014100979Srwatson FREEBSD_MAC_EXTATTR_NAMESPACE, FREEBSD_MAC_EXTATTR_NAME, 3015100979Srwatson sizeof(extmac), (char *)&extmac, curthread); 3016100979Srwatson if (error) 3017100979Srwatson return (error); 3018100979Srwatson 3019100979Srwatson mac_relabel_vnode(ap->a_cred, vp, intlabel); 3020100979Srwatson 3021101308Sjeff vp->v_vflag |= VV_CACHEDLABEL; 3022100979Srwatson 3023100979Srwatson return (0); 3024100979Srwatson} 3025100979Srwatson 3026100979Srwatsonstatic int 3027100979Srwatsonvn_setlabel(struct vnode *vp, struct label *intlabel, struct ucred *cred) 3028100979Srwatson{ 3029100979Srwatson int error; 3030100979Srwatson 3031100979Srwatson if (vp->v_mount == NULL) { 3032100979Srwatson /* printf("vn_setlabel: null v_mount\n"); */ 3033103314Snjl if (vp->v_type != VNON) 3034103314Snjl printf("vn_setlabel: null v_mount with non-VNON\n"); 3035100979Srwatson return (EBADF); 3036100979Srwatson } 3037100979Srwatson 3038100979Srwatson if ((vp->v_mount->mnt_flag & MNT_MULTILABEL) == 0) 3039100979Srwatson return (EOPNOTSUPP); 3040100979Srwatson 3041100979Srwatson /* 3042100979Srwatson * Multi-phase commit. First check the policies to confirm the 3043100979Srwatson * change is OK. Then commit via the filesystem. Finally, 3044100979Srwatson * update the actual vnode label. Question: maybe the filesystem 3045100979Srwatson * should update the vnode at the end as part of VOP_SETLABEL()? 3046100979Srwatson */ 3047100979Srwatson error = mac_check_vnode_relabel(cred, vp, intlabel); 3048100979Srwatson if (error) 3049100979Srwatson return (error); 3050100979Srwatson 3051100979Srwatson /* 3052100979Srwatson * VADMIN provides the opportunity for the filesystem to make 3053100979Srwatson * decisions about who is and is not able to modify labels 3054100979Srwatson * and protections on files. This might not be right. We can't 3055100979Srwatson * assume VOP_SETLABEL() will do it, because we might implement 3056100979Srwatson * that as part of vop_stdsetlabel_ea(). 3057100979Srwatson */ 3058100979Srwatson error = VOP_ACCESS(vp, VADMIN, cred, curthread); 3059100979Srwatson if (error) 3060100979Srwatson return (error); 3061100979Srwatson 3062100979Srwatson error = VOP_SETLABEL(vp, intlabel, cred, curthread); 3063100979Srwatson if (error) 3064100979Srwatson return (error); 3065100979Srwatson 3066100979Srwatson return (0); 3067100979Srwatson} 3068100979Srwatson 3069100979Srwatson/* 3070100979Srwatson * MPSAFE 3071100979Srwatson */ 3072100979Srwatsonint 3073100894Srwatson__mac_get_proc(struct thread *td, struct __mac_get_proc_args *uap) 3074100894Srwatson{ 3075100979Srwatson struct mac extmac; 3076100979Srwatson int error; 3077100894Srwatson 3078100979Srwatson error = mac_externalize(&td->td_ucred->cr_label, &extmac); 3079100979Srwatson if (error == 0) 3080100979Srwatson error = copyout(&extmac, SCARG(uap, mac_p), sizeof(extmac)); 3081100979Srwatson 3082100979Srwatson return (error); 3083100979Srwatson} 3084100979Srwatson 3085100979Srwatson/* 3086100979Srwatson * MPSAFE 3087100979Srwatson */ 3088100979Srwatsonint 3089100979Srwatson__mac_set_proc(struct thread *td, struct __mac_set_proc_args *uap) 3090100979Srwatson{ 3091100979Srwatson struct ucred *newcred, *oldcred; 3092100979Srwatson struct proc *p; 3093100979Srwatson struct mac extmac; 3094100979Srwatson struct label intlabel; 3095100979Srwatson int error; 3096100979Srwatson 3097100979Srwatson error = copyin(SCARG(uap, mac_p), &extmac, sizeof(extmac)); 3098100979Srwatson if (error) 3099100979Srwatson return (error); 3100100979Srwatson 3101100979Srwatson error = mac_internalize(&intlabel, &extmac); 3102100979Srwatson if (error) 3103100979Srwatson return (error); 3104100979Srwatson 3105100979Srwatson newcred = crget(); 3106100979Srwatson 3107100979Srwatson p = td->td_proc; 3108100979Srwatson PROC_LOCK(p); 3109100979Srwatson oldcred = p->p_ucred; 3110100979Srwatson 3111100979Srwatson error = mac_check_cred_relabel(oldcred, &intlabel); 3112100979Srwatson if (error) { 3113100979Srwatson PROC_UNLOCK(p); 3114100979Srwatson mac_destroy_temp(&intlabel); 3115100979Srwatson crfree(newcred); 3116100979Srwatson return (error); 3117100979Srwatson } 3118100979Srwatson 3119100979Srwatson setsugid(p); 3120100979Srwatson crcopy(newcred, oldcred); 3121100979Srwatson mac_relabel_cred(newcred, &intlabel); 3122102136Srwatson p->p_ucred = newcred; 3123100979Srwatson 3124102136Srwatson /* 3125102136Srwatson * Grab additional reference for use while revoking mmaps, prior 3126102136Srwatson * to releasing the proc lock and sharing the cred. 3127102136Srwatson */ 3128102136Srwatson crhold(newcred); 3129100979Srwatson PROC_UNLOCK(p); 3130102136Srwatson 3131103135Srwatson mtx_lock(&Giant); 3132102136Srwatson mac_cred_mmapped_drop_perms(td, newcred); 3133103135Srwatson mtx_unlock(&Giant); 3134102136Srwatson 3135102136Srwatson crfree(newcred); /* Free revocation reference. */ 3136100979Srwatson crfree(oldcred); 3137100979Srwatson mac_destroy_temp(&intlabel); 3138100979Srwatson return (0); 3139100979Srwatson} 3140100979Srwatson 3141100979Srwatson/* 3142100979Srwatson * MPSAFE 3143100979Srwatson */ 3144100979Srwatsonint 3145100979Srwatson__mac_get_fd(struct thread *td, struct __mac_get_fd_args *uap) 3146100979Srwatson{ 3147100979Srwatson struct file *fp; 3148100979Srwatson struct mac extmac; 3149100979Srwatson struct vnode *vp; 3150100979Srwatson struct pipe *pipe; 3151100979Srwatson int error; 3152100979Srwatson 3153100979Srwatson mtx_lock(&Giant); 3154100979Srwatson 3155100979Srwatson error = fget(td, SCARG(uap, fd), &fp); 3156100979Srwatson if (error) 3157100979Srwatson goto out; 3158100979Srwatson 3159100979Srwatson switch (fp->f_type) { 3160100979Srwatson case DTYPE_FIFO: 3161100979Srwatson case DTYPE_VNODE: 3162100979Srwatson vp = (struct vnode *)fp->f_data; 3163100979Srwatson 3164100979Srwatson vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 3165100979Srwatson error = vn_refreshlabel(vp, td->td_ucred); 3166100979Srwatson if (error == 0) 3167100979Srwatson error = mac_externalize(&vp->v_label, &extmac); 3168100979Srwatson VOP_UNLOCK(vp, 0, td); 3169100979Srwatson break; 3170100979Srwatson case DTYPE_PIPE: 3171100979Srwatson pipe = (struct pipe *)fp->f_data; 3172100979Srwatson error = mac_externalize(pipe->pipe_label, &extmac); 3173100979Srwatson break; 3174100979Srwatson default: 3175100979Srwatson error = EINVAL; 3176100979Srwatson } 3177100979Srwatson 3178100979Srwatson if (error == 0) 3179100979Srwatson error = copyout(&extmac, SCARG(uap, mac_p), sizeof(extmac)); 3180100979Srwatson 3181100979Srwatson fdrop(fp, td); 3182100979Srwatson 3183100979Srwatsonout: 3184100979Srwatson mtx_unlock(&Giant); 3185100979Srwatson return (error); 3186100979Srwatson} 3187100979Srwatson 3188100979Srwatson/* 3189100979Srwatson * MPSAFE 3190100979Srwatson */ 3191100979Srwatsonint 3192100979Srwatson__mac_get_file(struct thread *td, struct __mac_get_file_args *uap) 3193100979Srwatson{ 3194100979Srwatson struct nameidata nd; 3195100979Srwatson struct mac extmac; 3196100979Srwatson int error; 3197100979Srwatson 3198100979Srwatson mtx_lock(&Giant); 3199100979Srwatson NDINIT(&nd, LOOKUP, LOCKLEAF | FOLLOW, UIO_USERSPACE, 3200100979Srwatson SCARG(uap, path_p), td); 3201100979Srwatson error = namei(&nd); 3202100979Srwatson if (error) 3203100979Srwatson goto out; 3204100979Srwatson 3205100979Srwatson error = vn_refreshlabel(nd.ni_vp, td->td_ucred); 3206100979Srwatson if (error == 0) 3207100979Srwatson error = mac_externalize(&nd.ni_vp->v_label, &extmac); 3208100979Srwatson NDFREE(&nd, 0); 3209100979Srwatson if (error) 3210100979Srwatson goto out; 3211100979Srwatson 3212100979Srwatson error = copyout(&extmac, SCARG(uap, mac_p), sizeof(extmac)); 3213100979Srwatson 3214100979Srwatsonout: 3215100979Srwatson mtx_unlock(&Giant); 3216100979Srwatson return (error); 3217100979Srwatson} 3218100979Srwatson 3219100979Srwatson/* 3220100979Srwatson * MPSAFE 3221100979Srwatson */ 3222100979Srwatsonint 3223100979Srwatson__mac_set_fd(struct thread *td, struct __mac_set_fd_args *uap) 3224100979Srwatson{ 3225100979Srwatson struct file *fp; 3226100979Srwatson struct mac extmac; 3227100979Srwatson struct label intlabel; 3228100979Srwatson struct mount *mp; 3229100979Srwatson struct vnode *vp; 3230100979Srwatson struct pipe *pipe; 3231100979Srwatson int error; 3232100979Srwatson 3233100979Srwatson mtx_lock(&Giant); 3234100979Srwatson error = fget(td, SCARG(uap, fd), &fp); 3235100979Srwatson if (error) 3236100979Srwatson goto out1; 3237100979Srwatson 3238100979Srwatson error = copyin(SCARG(uap, mac_p), &extmac, sizeof(extmac)); 3239100979Srwatson if (error) 3240100979Srwatson goto out2; 3241100979Srwatson 3242100979Srwatson error = mac_internalize(&intlabel, &extmac); 3243100979Srwatson if (error) 3244100979Srwatson goto out2; 3245100979Srwatson 3246100979Srwatson switch (fp->f_type) { 3247100979Srwatson case DTYPE_FIFO: 3248100979Srwatson case DTYPE_VNODE: 3249100979Srwatson vp = (struct vnode *)fp->f_data; 3250100979Srwatson error = vn_start_write(vp, &mp, V_WAIT | PCATCH); 3251100979Srwatson if (error != 0) 3252100979Srwatson break; 3253100979Srwatson 3254100979Srwatson vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 3255100979Srwatson error = vn_setlabel(vp, &intlabel, td->td_ucred); 3256100979Srwatson VOP_UNLOCK(vp, 0, td); 3257100979Srwatson vn_finished_write(mp); 3258100979Srwatson mac_destroy_temp(&intlabel); 3259100979Srwatson break; 3260100979Srwatson case DTYPE_PIPE: 3261100979Srwatson pipe = (struct pipe *)fp->f_data; 3262104269Srwatson PIPE_LOCK(pipe); 3263100979Srwatson error = mac_pipe_label_set(td->td_ucred, pipe, &intlabel); 3264104269Srwatson PIPE_UNLOCK(pipe); 3265100979Srwatson break; 3266100979Srwatson default: 3267100979Srwatson error = EINVAL; 3268100979Srwatson } 3269100979Srwatson 3270100979Srwatsonout2: 3271100979Srwatson fdrop(fp, td); 3272100979Srwatsonout1: 3273100979Srwatson mtx_unlock(&Giant); 3274100979Srwatson return (error); 3275100979Srwatson} 3276100979Srwatson 3277100979Srwatson/* 3278100979Srwatson * MPSAFE 3279100979Srwatson */ 3280100979Srwatsonint 3281100979Srwatson__mac_set_file(struct thread *td, struct __mac_set_file_args *uap) 3282100979Srwatson{ 3283100979Srwatson struct nameidata nd; 3284100979Srwatson struct mac extmac; 3285100979Srwatson struct label intlabel; 3286100979Srwatson struct mount *mp; 3287100979Srwatson int error; 3288100979Srwatson 3289100979Srwatson mtx_lock(&Giant); 3290100979Srwatson 3291100979Srwatson error = copyin(SCARG(uap, mac_p), &extmac, sizeof(extmac)); 3292100979Srwatson if (error) 3293100979Srwatson goto out; 3294100979Srwatson 3295100979Srwatson error = mac_internalize(&intlabel, &extmac); 3296100979Srwatson if (error) 3297100979Srwatson goto out; 3298100979Srwatson 3299100979Srwatson NDINIT(&nd, LOOKUP, LOCKLEAF | FOLLOW, UIO_USERSPACE, 3300100979Srwatson SCARG(uap, path_p), td); 3301100979Srwatson error = namei(&nd); 3302100979Srwatson if (error) 3303100979Srwatson goto out2; 3304100979Srwatson error = vn_start_write(nd.ni_vp, &mp, V_WAIT | PCATCH); 3305100979Srwatson if (error) 3306100979Srwatson goto out2; 3307100979Srwatson 3308100979Srwatson error = vn_setlabel(nd.ni_vp, &intlabel, td->td_ucred); 3309100979Srwatson 3310100979Srwatson vn_finished_write(mp); 3311100979Srwatsonout2: 3312100979Srwatson mac_destroy_temp(&intlabel); 3313100979Srwatson NDFREE(&nd, 0); 3314100979Srwatsonout: 3315100979Srwatson mtx_unlock(&Giant); 3316100979Srwatson return (error); 3317100979Srwatson} 3318100979Srwatson 3319102123Srwatsonint 3320102123Srwatsonmac_syscall(struct thread *td, struct mac_syscall_args *uap) 3321102123Srwatson{ 3322102123Srwatson struct mac_policy_conf *mpc; 3323102123Srwatson char target[MAC_MAX_POLICY_NAME]; 3324102123Srwatson int error; 3325102123Srwatson 3326102123Srwatson error = copyinstr(SCARG(uap, policy), target, sizeof(target), NULL); 3327102123Srwatson if (error) 3328102123Srwatson return (error); 3329102123Srwatson 3330102123Srwatson error = ENOSYS; 3331102123Srwatson MAC_POLICY_LIST_BUSY(); 3332102123Srwatson LIST_FOREACH(mpc, &mac_policy_list, mpc_list) { 3333102123Srwatson if (strcmp(mpc->mpc_name, target) == 0 && 3334102123Srwatson mpc->mpc_ops->mpo_syscall != NULL) { 3335102123Srwatson error = mpc->mpc_ops->mpo_syscall(td, 3336102123Srwatson SCARG(uap, call), SCARG(uap, arg)); 3337102123Srwatson goto out; 3338102123Srwatson } 3339102123Srwatson } 3340102123Srwatson 3341102123Srwatsonout: 3342102123Srwatson MAC_POLICY_LIST_UNBUSY(); 3343102123Srwatson return (error); 3344102123Srwatson} 3345102123Srwatson 3346100979SrwatsonSYSINIT(mac, SI_SUB_MAC, SI_ORDER_FIRST, mac_init, NULL); 3347100979SrwatsonSYSINIT(mac_late, SI_SUB_MAC_LATE, SI_ORDER_FIRST, mac_late_init, NULL); 3348100979Srwatson 3349100979Srwatson#else /* !MAC */ 3350100979Srwatson 3351100979Srwatsonint 3352100979Srwatson__mac_get_proc(struct thread *td, struct __mac_get_proc_args *uap) 3353100979Srwatson{ 3354100979Srwatson 3355100894Srwatson return (ENOSYS); 3356100894Srwatson} 3357100894Srwatson 3358100894Srwatsonint 3359100894Srwatson__mac_set_proc(struct thread *td, struct __mac_set_proc_args *uap) 3360100894Srwatson{ 3361100894Srwatson 3362100894Srwatson return (ENOSYS); 3363100894Srwatson} 3364100894Srwatson 3365100894Srwatsonint 3366100894Srwatson__mac_get_fd(struct thread *td, struct __mac_get_fd_args *uap) 3367100894Srwatson{ 3368100894Srwatson 3369100894Srwatson return (ENOSYS); 3370100894Srwatson} 3371100894Srwatson 3372100894Srwatsonint 3373100894Srwatson__mac_get_file(struct thread *td, struct __mac_get_file_args *uap) 3374100894Srwatson{ 3375100894Srwatson 3376100894Srwatson return (ENOSYS); 3377100894Srwatson} 3378100894Srwatson 3379100894Srwatsonint 3380100894Srwatson__mac_set_fd(struct thread *td, struct __mac_set_fd_args *uap) 3381100894Srwatson{ 3382100894Srwatson 3383100894Srwatson return (ENOSYS); 3384100894Srwatson} 3385100894Srwatson 3386100894Srwatsonint 3387100894Srwatson__mac_set_file(struct thread *td, struct __mac_set_file_args *uap) 3388100894Srwatson{ 3389100894Srwatson 3390100894Srwatson return (ENOSYS); 3391100894Srwatson} 3392100979Srwatson 3393102123Srwatsonint 3394102123Srwatsonmac_syscall(struct thread *td, struct mac_syscall_args *uap) 3395102123Srwatson{ 3396102123Srwatson 3397102123Srwatson return (ENOSYS); 3398102123Srwatson} 3399102123Srwatson 3400100979Srwatson#endif /* !MAC */ 3401