1/* 2 * Linux Security plug 3 * 4 * Copyright (C) 2001 WireX Communications, Inc <chris@wirex.com> 5 * Copyright (C) 2001 Greg Kroah-Hartman <greg@kroah.com> 6 * Copyright (C) 2001 Networks Associates Technology, Inc <ssmalley@nai.com> 7 * Copyright (C) 2001 James Morris <jmorris@intercode.com.au> 8 * Copyright (C) 2001 Silicon Graphics, Inc. (Trust Technology Group) 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * Due to this file being licensed under the GPL there is controversy over 16 * whether this permits you to write a module that #includes this file 17 * without placing your module under the GPL. Please consult a lawyer for 18 * advice before doing this. 19 * 20 */ 21 22#ifndef __LINUX_SECURITY_H 23#define __LINUX_SECURITY_H 24 25#include <linux/fs.h> 26#include <linux/binfmts.h> 27#include <linux/signal.h> 28#include <linux/resource.h> 29#include <linux/sem.h> 30#include <linux/shm.h> 31#include <linux/msg.h> 32#include <linux/sched.h> 33#include <linux/key.h> 34#include <linux/xfrm.h> 35#include <net/flow.h> 36 37struct ctl_table; 38 39/* 40 * These functions are in security/capability.c and are used 41 * as the default capabilities functions 42 */ 43extern int cap_capable (struct task_struct *tsk, int cap); 44extern int cap_settime (struct timespec *ts, struct timezone *tz); 45extern int cap_ptrace (struct task_struct *parent, struct task_struct *child); 46extern int cap_capget (struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted); 47extern int cap_capset_check (struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted); 48extern void cap_capset_set (struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted); 49extern int cap_bprm_set_security (struct linux_binprm *bprm); 50extern void cap_bprm_apply_creds (struct linux_binprm *bprm, int unsafe); 51extern int cap_bprm_secureexec(struct linux_binprm *bprm); 52extern int cap_inode_setxattr(struct dentry *dentry, char *name, void *value, size_t size, int flags); 53extern int cap_inode_removexattr(struct dentry *dentry, char *name); 54extern int cap_task_post_setuid (uid_t old_ruid, uid_t old_euid, uid_t old_suid, int flags); 55extern void cap_task_reparent_to_init (struct task_struct *p); 56extern int cap_syslog (int type); 57extern int cap_vm_enough_memory (long pages); 58 59struct msghdr; 60struct sk_buff; 61struct sock; 62struct sockaddr; 63struct socket; 64struct flowi; 65struct dst_entry; 66struct xfrm_selector; 67struct xfrm_policy; 68struct xfrm_state; 69struct xfrm_user_sec_ctx; 70 71extern int cap_netlink_send(struct sock *sk, struct sk_buff *skb); 72extern int cap_netlink_recv(struct sk_buff *skb, int cap); 73 74/* 75 * Values used in the task_security_ops calls 76 */ 77/* setuid or setgid, id0 == uid or gid */ 78#define LSM_SETID_ID 1 79 80/* setreuid or setregid, id0 == real, id1 == eff */ 81#define LSM_SETID_RE 2 82 83/* setresuid or setresgid, id0 == real, id1 == eff, uid2 == saved */ 84#define LSM_SETID_RES 4 85 86/* setfsuid or setfsgid, id0 == fsuid or fsgid */ 87#define LSM_SETID_FS 8 88 89/* forward declares to avoid warnings */ 90struct nfsctl_arg; 91struct sched_param; 92struct swap_info_struct; 93struct request_sock; 94 95/* bprm_apply_creds unsafe reasons */ 96#define LSM_UNSAFE_SHARE 1 97#define LSM_UNSAFE_PTRACE 2 98#define LSM_UNSAFE_PTRACE_CAP 4 99 100#ifdef CONFIG_SECURITY 101 102/** 103 * struct security_operations - main security structure 104 * 105 * Security hooks for program execution operations. 106 * 107 * @bprm_alloc_security: 108 * Allocate and attach a security structure to the @bprm->security field. 109 * The security field is initialized to NULL when the bprm structure is 110 * allocated. 111 * @bprm contains the linux_binprm structure to be modified. 112 * Return 0 if operation was successful. 113 * @bprm_free_security: 114 * @bprm contains the linux_binprm structure to be modified. 115 * Deallocate and clear the @bprm->security field. 116 * @bprm_apply_creds: 117 * Compute and set the security attributes of a process being transformed 118 * by an execve operation based on the old attributes (current->security) 119 * and the information saved in @bprm->security by the set_security hook. 120 * Since this hook function (and its caller) are void, this hook can not 121 * return an error. However, it can leave the security attributes of the 122 * process unchanged if an access failure occurs at this point. 123 * bprm_apply_creds is called under task_lock. @unsafe indicates various 124 * reasons why it may be unsafe to change security state. 125 * @bprm contains the linux_binprm structure. 126 * @bprm_post_apply_creds: 127 * Runs after bprm_apply_creds with the task_lock dropped, so that 128 * functions which cannot be called safely under the task_lock can 129 * be used. This hook is a good place to perform state changes on 130 * the process such as closing open file descriptors to which access 131 * is no longer granted if the attributes were changed. 132 * Note that a security module might need to save state between 133 * bprm_apply_creds and bprm_post_apply_creds to store the decision 134 * on whether the process may proceed. 135 * @bprm contains the linux_binprm structure. 136 * @bprm_set_security: 137 * Save security information in the bprm->security field, typically based 138 * on information about the bprm->file, for later use by the apply_creds 139 * hook. This hook may also optionally check permissions (e.g. for 140 * transitions between security domains). 141 * This hook may be called multiple times during a single execve, e.g. for 142 * interpreters. The hook can tell whether it has already been called by 143 * checking to see if @bprm->security is non-NULL. If so, then the hook 144 * may decide either to retain the security information saved earlier or 145 * to replace it. 146 * @bprm contains the linux_binprm structure. 147 * Return 0 if the hook is successful and permission is granted. 148 * @bprm_check_security: 149 * This hook mediates the point when a search for a binary handler will 150 * begin. It allows a check the @bprm->security value which is set in 151 * the preceding set_security call. The primary difference from 152 * set_security is that the argv list and envp list are reliably 153 * available in @bprm. This hook may be called multiple times 154 * during a single execve; and in each pass set_security is called 155 * first. 156 * @bprm contains the linux_binprm structure. 157 * Return 0 if the hook is successful and permission is granted. 158 * @bprm_secureexec: 159 * Return a boolean value (0 or 1) indicating whether a "secure exec" 160 * is required. The flag is passed in the auxiliary table 161 * on the initial stack to the ELF interpreter to indicate whether libc 162 * should enable secure mode. 163 * @bprm contains the linux_binprm structure. 164 * 165 * Security hooks for filesystem operations. 166 * 167 * @sb_alloc_security: 168 * Allocate and attach a security structure to the sb->s_security field. 169 * The s_security field is initialized to NULL when the structure is 170 * allocated. 171 * @sb contains the super_block structure to be modified. 172 * Return 0 if operation was successful. 173 * @sb_free_security: 174 * Deallocate and clear the sb->s_security field. 175 * @sb contains the super_block structure to be modified. 176 * @sb_statfs: 177 * Check permission before obtaining filesystem statistics for the @mnt 178 * mountpoint. 179 * @dentry is a handle on the superblock for the filesystem. 180 * Return 0 if permission is granted. 181 * @sb_mount: 182 * Check permission before an object specified by @dev_name is mounted on 183 * the mount point named by @nd. For an ordinary mount, @dev_name 184 * identifies a device if the file system type requires a device. For a 185 * remount (@flags & MS_REMOUNT), @dev_name is irrelevant. For a 186 * loopback/bind mount (@flags & MS_BIND), @dev_name identifies the 187 * pathname of the object being mounted. 188 * @dev_name contains the name for object being mounted. 189 * @nd contains the nameidata structure for mount point object. 190 * @type contains the filesystem type. 191 * @flags contains the mount flags. 192 * @data contains the filesystem-specific data. 193 * Return 0 if permission is granted. 194 * @sb_copy_data: 195 * Allow mount option data to be copied prior to parsing by the filesystem, 196 * so that the security module can extract security-specific mount 197 * options cleanly (a filesystem may modify the data e.g. with strsep()). 198 * This also allows the original mount data to be stripped of security- 199 * specific options to avoid having to make filesystems aware of them. 200 * @type the type of filesystem being mounted. 201 * @orig the original mount data copied from userspace. 202 * @copy copied data which will be passed to the security module. 203 * Returns 0 if the copy was successful. 204 * @sb_check_sb: 205 * Check permission before the device with superblock @mnt->sb is mounted 206 * on the mount point named by @nd. 207 * @mnt contains the vfsmount for device being mounted. 208 * @nd contains the nameidata object for the mount point. 209 * Return 0 if permission is granted. 210 * @sb_umount: 211 * Check permission before the @mnt file system is unmounted. 212 * @mnt contains the mounted file system. 213 * @flags contains the unmount flags, e.g. MNT_FORCE. 214 * Return 0 if permission is granted. 215 * @sb_umount_close: 216 * Close any files in the @mnt mounted filesystem that are held open by 217 * the security module. This hook is called during an umount operation 218 * prior to checking whether the filesystem is still busy. 219 * @mnt contains the mounted filesystem. 220 * @sb_umount_busy: 221 * Handle a failed umount of the @mnt mounted filesystem, e.g. re-opening 222 * any files that were closed by umount_close. This hook is called during 223 * an umount operation if the umount fails after a call to the 224 * umount_close hook. 225 * @mnt contains the mounted filesystem. 226 * @sb_post_remount: 227 * Update the security module's state when a filesystem is remounted. 228 * This hook is only called if the remount was successful. 229 * @mnt contains the mounted file system. 230 * @flags contains the new filesystem flags. 231 * @data contains the filesystem-specific data. 232 * @sb_post_mountroot: 233 * Update the security module's state when the root filesystem is mounted. 234 * This hook is only called if the mount was successful. 235 * @sb_post_addmount: 236 * Update the security module's state when a filesystem is mounted. 237 * This hook is called any time a mount is successfully grafetd to 238 * the tree. 239 * @mnt contains the mounted filesystem. 240 * @mountpoint_nd contains the nameidata structure for the mount point. 241 * @sb_pivotroot: 242 * Check permission before pivoting the root filesystem. 243 * @old_nd contains the nameidata structure for the new location of the current root (put_old). 244 * @new_nd contains the nameidata structure for the new root (new_root). 245 * Return 0 if permission is granted. 246 * @sb_post_pivotroot: 247 * Update module state after a successful pivot. 248 * @old_nd contains the nameidata structure for the old root. 249 * @new_nd contains the nameidata structure for the new root. 250 * 251 * Security hooks for inode operations. 252 * 253 * @inode_alloc_security: 254 * Allocate and attach a security structure to @inode->i_security. The 255 * i_security field is initialized to NULL when the inode structure is 256 * allocated. 257 * @inode contains the inode structure. 258 * Return 0 if operation was successful. 259 * @inode_free_security: 260 * @inode contains the inode structure. 261 * Deallocate the inode security structure and set @inode->i_security to 262 * NULL. 263 * @inode_init_security: 264 * Obtain the security attribute name suffix and value to set on a newly 265 * created inode and set up the incore security field for the new inode. 266 * This hook is called by the fs code as part of the inode creation 267 * transaction and provides for atomic labeling of the inode, unlike 268 * the post_create/mkdir/... hooks called by the VFS. The hook function 269 * is expected to allocate the name and value via kmalloc, with the caller 270 * being responsible for calling kfree after using them. 271 * If the security module does not use security attributes or does 272 * not wish to put a security attribute on this particular inode, 273 * then it should return -EOPNOTSUPP to skip this processing. 274 * @inode contains the inode structure of the newly created inode. 275 * @dir contains the inode structure of the parent directory. 276 * @name will be set to the allocated name suffix (e.g. selinux). 277 * @value will be set to the allocated attribute value. 278 * @len will be set to the length of the value. 279 * Returns 0 if @name and @value have been successfully set, 280 * -EOPNOTSUPP if no security attribute is needed, or 281 * -ENOMEM on memory allocation failure. 282 * @inode_create: 283 * Check permission to create a regular file. 284 * @dir contains inode structure of the parent of the new file. 285 * @dentry contains the dentry structure for the file to be created. 286 * @mode contains the file mode of the file to be created. 287 * Return 0 if permission is granted. 288 * @inode_link: 289 * Check permission before creating a new hard link to a file. 290 * @old_dentry contains the dentry structure for an existing link to the file. 291 * @dir contains the inode structure of the parent directory of the new link. 292 * @new_dentry contains the dentry structure for the new link. 293 * Return 0 if permission is granted. 294 * @inode_unlink: 295 * Check the permission to remove a hard link to a file. 296 * @dir contains the inode structure of parent directory of the file. 297 * @dentry contains the dentry structure for file to be unlinked. 298 * Return 0 if permission is granted. 299 * @inode_symlink: 300 * Check the permission to create a symbolic link to a file. 301 * @dir contains the inode structure of parent directory of the symbolic link. 302 * @dentry contains the dentry structure of the symbolic link. 303 * @old_name contains the pathname of file. 304 * Return 0 if permission is granted. 305 * @inode_mkdir: 306 * Check permissions to create a new directory in the existing directory 307 * associated with inode strcture @dir. 308 * @dir containst the inode structure of parent of the directory to be created. 309 * @dentry contains the dentry structure of new directory. 310 * @mode contains the mode of new directory. 311 * Return 0 if permission is granted. 312 * @inode_rmdir: 313 * Check the permission to remove a directory. 314 * @dir contains the inode structure of parent of the directory to be removed. 315 * @dentry contains the dentry structure of directory to be removed. 316 * Return 0 if permission is granted. 317 * @inode_mknod: 318 * Check permissions when creating a special file (or a socket or a fifo 319 * file created via the mknod system call). Note that if mknod operation 320 * is being done for a regular file, then the create hook will be called 321 * and not this hook. 322 * @dir contains the inode structure of parent of the new file. 323 * @dentry contains the dentry structure of the new file. 324 * @mode contains the mode of the new file. 325 * @dev contains the device number. 326 * Return 0 if permission is granted. 327 * @inode_rename: 328 * Check for permission to rename a file or directory. 329 * @old_dir contains the inode structure for parent of the old link. 330 * @old_dentry contains the dentry structure of the old link. 331 * @new_dir contains the inode structure for parent of the new link. 332 * @new_dentry contains the dentry structure of the new link. 333 * Return 0 if permission is granted. 334 * @inode_readlink: 335 * Check the permission to read the symbolic link. 336 * @dentry contains the dentry structure for the file link. 337 * Return 0 if permission is granted. 338 * @inode_follow_link: 339 * Check permission to follow a symbolic link when looking up a pathname. 340 * @dentry contains the dentry structure for the link. 341 * @nd contains the nameidata structure for the parent directory. 342 * Return 0 if permission is granted. 343 * @inode_permission: 344 * Check permission before accessing an inode. This hook is called by the 345 * existing Linux permission function, so a security module can use it to 346 * provide additional checking for existing Linux permission checks. 347 * Notice that this hook is called when a file is opened (as well as many 348 * other operations), whereas the file_security_ops permission hook is 349 * called when the actual read/write operations are performed. 350 * @inode contains the inode structure to check. 351 * @mask contains the permission mask. 352 * @nd contains the nameidata (may be NULL). 353 * Return 0 if permission is granted. 354 * @inode_setattr: 355 * Check permission before setting file attributes. Note that the kernel 356 * call to notify_change is performed from several locations, whenever 357 * file attributes change (such as when a file is truncated, chown/chmod 358 * operations, transferring disk quotas, etc). 359 * @dentry contains the dentry structure for the file. 360 * @attr is the iattr structure containing the new file attributes. 361 * Return 0 if permission is granted. 362 * @inode_getattr: 363 * Check permission before obtaining file attributes. 364 * @mnt is the vfsmount where the dentry was looked up 365 * @dentry contains the dentry structure for the file. 366 * Return 0 if permission is granted. 367 * @inode_delete: 368 * @inode contains the inode structure for deleted inode. 369 * This hook is called when a deleted inode is released (i.e. an inode 370 * with no hard links has its use count drop to zero). A security module 371 * can use this hook to release any persistent label associated with the 372 * inode. 373 * @inode_setxattr: 374 * Check permission before setting the extended attributes 375 * @value identified by @name for @dentry. 376 * Return 0 if permission is granted. 377 * @inode_post_setxattr: 378 * Update inode security field after successful setxattr operation. 379 * @value identified by @name for @dentry. 380 * @inode_getxattr: 381 * Check permission before obtaining the extended attributes 382 * identified by @name for @dentry. 383 * Return 0 if permission is granted. 384 * @inode_listxattr: 385 * Check permission before obtaining the list of extended attribute 386 * names for @dentry. 387 * Return 0 if permission is granted. 388 * @inode_removexattr: 389 * Check permission before removing the extended attribute 390 * identified by @name for @dentry. 391 * Return 0 if permission is granted. 392 * @inode_getsecurity: 393 * Copy the extended attribute representation of the security label 394 * associated with @name for @inode into @buffer. @buffer may be 395 * NULL to request the size of the buffer required. @size indicates 396 * the size of @buffer in bytes. Note that @name is the remainder 397 * of the attribute name after the security. prefix has been removed. 398 * @err is the return value from the preceding fs getxattr call, 399 * and can be used by the security module to determine whether it 400 * should try and canonicalize the attribute value. 401 * Return number of bytes used/required on success. 402 * @inode_setsecurity: 403 * Set the security label associated with @name for @inode from the 404 * extended attribute value @value. @size indicates the size of the 405 * @value in bytes. @flags may be XATTR_CREATE, XATTR_REPLACE, or 0. 406 * Note that @name is the remainder of the attribute name after the 407 * security. prefix has been removed. 408 * Return 0 on success. 409 * @inode_listsecurity: 410 * Copy the extended attribute names for the security labels 411 * associated with @inode into @buffer. The maximum size of @buffer 412 * is specified by @buffer_size. @buffer may be NULL to request 413 * the size of the buffer required. 414 * Returns number of bytes used/required on success. 415 * 416 * Security hooks for file operations 417 * 418 * @file_permission: 419 * Check file permissions before accessing an open file. This hook is 420 * called by various operations that read or write files. A security 421 * module can use this hook to perform additional checking on these 422 * operations, e.g. to revalidate permissions on use to support privilege 423 * bracketing or policy changes. Notice that this hook is used when the 424 * actual read/write operations are performed, whereas the 425 * inode_security_ops hook is called when a file is opened (as well as 426 * many other operations). 427 * Caveat: Although this hook can be used to revalidate permissions for 428 * various system call operations that read or write files, it does not 429 * address the revalidation of permissions for memory-mapped files. 430 * Security modules must handle this separately if they need such 431 * revalidation. 432 * @file contains the file structure being accessed. 433 * @mask contains the requested permissions. 434 * Return 0 if permission is granted. 435 * @file_alloc_security: 436 * Allocate and attach a security structure to the file->f_security field. 437 * The security field is initialized to NULL when the structure is first 438 * created. 439 * @file contains the file structure to secure. 440 * Return 0 if the hook is successful and permission is granted. 441 * @file_free_security: 442 * Deallocate and free any security structures stored in file->f_security. 443 * @file contains the file structure being modified. 444 * @file_ioctl: 445 * @file contains the file structure. 446 * @cmd contains the operation to perform. 447 * @arg contains the operational arguments. 448 * Check permission for an ioctl operation on @file. Note that @arg can 449 * sometimes represents a user space pointer; in other cases, it may be a 450 * simple integer value. When @arg represents a user space pointer, it 451 * should never be used by the security module. 452 * Return 0 if permission is granted. 453 * @file_mmap : 454 * Check permissions for a mmap operation. The @file may be NULL, e.g. 455 * if mapping anonymous memory. 456 * @file contains the file structure for file to map (may be NULL). 457 * @reqprot contains the protection requested by the application. 458 * @prot contains the protection that will be applied by the kernel. 459 * @flags contains the operational flags. 460 * Return 0 if permission is granted. 461 * @file_mprotect: 462 * Check permissions before changing memory access permissions. 463 * @vma contains the memory region to modify. 464 * @reqprot contains the protection requested by the application. 465 * @prot contains the protection that will be applied by the kernel. 466 * Return 0 if permission is granted. 467 * @file_lock: 468 * Check permission before performing file locking operations. 469 * Note: this hook mediates both flock and fcntl style locks. 470 * @file contains the file structure. 471 * @cmd contains the posix-translated lock operation to perform 472 * (e.g. F_RDLCK, F_WRLCK). 473 * Return 0 if permission is granted. 474 * @file_fcntl: 475 * Check permission before allowing the file operation specified by @cmd 476 * from being performed on the file @file. Note that @arg can sometimes 477 * represents a user space pointer; in other cases, it may be a simple 478 * integer value. When @arg represents a user space pointer, it should 479 * never be used by the security module. 480 * @file contains the file structure. 481 * @cmd contains the operation to be performed. 482 * @arg contains the operational arguments. 483 * Return 0 if permission is granted. 484 * @file_set_fowner: 485 * Save owner security information (typically from current->security) in 486 * file->f_security for later use by the send_sigiotask hook. 487 * @file contains the file structure to update. 488 * Return 0 on success. 489 * @file_send_sigiotask: 490 * Check permission for the file owner @fown to send SIGIO or SIGURG to the 491 * process @tsk. Note that this hook is sometimes called from interrupt. 492 * Note that the fown_struct, @fown, is never outside the context of a 493 * struct file, so the file structure (and associated security information) 494 * can always be obtained: 495 * container_of(fown, struct file, f_owner) 496 * @tsk contains the structure of task receiving signal. 497 * @fown contains the file owner information. 498 * @sig is the signal that will be sent. When 0, kernel sends SIGIO. 499 * Return 0 if permission is granted. 500 * @file_receive: 501 * This hook allows security modules to control the ability of a process 502 * to receive an open file descriptor via socket IPC. 503 * @file contains the file structure being received. 504 * Return 0 if permission is granted. 505 * 506 * Security hooks for task operations. 507 * 508 * @task_create: 509 * Check permission before creating a child process. See the clone(2) 510 * manual page for definitions of the @clone_flags. 511 * @clone_flags contains the flags indicating what should be shared. 512 * Return 0 if permission is granted. 513 * @task_alloc_security: 514 * @p contains the task_struct for child process. 515 * Allocate and attach a security structure to the p->security field. The 516 * security field is initialized to NULL when the task structure is 517 * allocated. 518 * Return 0 if operation was successful. 519 * @task_free_security: 520 * @p contains the task_struct for process. 521 * Deallocate and clear the p->security field. 522 * @task_setuid: 523 * Check permission before setting one or more of the user identity 524 * attributes of the current process. The @flags parameter indicates 525 * which of the set*uid system calls invoked this hook and how to 526 * interpret the @id0, @id1, and @id2 parameters. See the LSM_SETID 527 * definitions at the beginning of this file for the @flags values and 528 * their meanings. 529 * @id0 contains a uid. 530 * @id1 contains a uid. 531 * @id2 contains a uid. 532 * @flags contains one of the LSM_SETID_* values. 533 * Return 0 if permission is granted. 534 * @task_post_setuid: 535 * Update the module's state after setting one or more of the user 536 * identity attributes of the current process. The @flags parameter 537 * indicates which of the set*uid system calls invoked this hook. If 538 * @flags is LSM_SETID_FS, then @old_ruid is the old fs uid and the other 539 * parameters are not used. 540 * @old_ruid contains the old real uid (or fs uid if LSM_SETID_FS). 541 * @old_euid contains the old effective uid (or -1 if LSM_SETID_FS). 542 * @old_suid contains the old saved uid (or -1 if LSM_SETID_FS). 543 * @flags contains one of the LSM_SETID_* values. 544 * Return 0 on success. 545 * @task_setgid: 546 * Check permission before setting one or more of the group identity 547 * attributes of the current process. The @flags parameter indicates 548 * which of the set*gid system calls invoked this hook and how to 549 * interpret the @id0, @id1, and @id2 parameters. See the LSM_SETID 550 * definitions at the beginning of this file for the @flags values and 551 * their meanings. 552 * @id0 contains a gid. 553 * @id1 contains a gid. 554 * @id2 contains a gid. 555 * @flags contains one of the LSM_SETID_* values. 556 * Return 0 if permission is granted. 557 * @task_setpgid: 558 * Check permission before setting the process group identifier of the 559 * process @p to @pgid. 560 * @p contains the task_struct for process being modified. 561 * @pgid contains the new pgid. 562 * Return 0 if permission is granted. 563 * @task_getpgid: 564 * Check permission before getting the process group identifier of the 565 * process @p. 566 * @p contains the task_struct for the process. 567 * Return 0 if permission is granted. 568 * @task_getsid: 569 * Check permission before getting the session identifier of the process 570 * @p. 571 * @p contains the task_struct for the process. 572 * Return 0 if permission is granted. 573 * @task_getsecid: 574 * Retrieve the security identifier of the process @p. 575 * @p contains the task_struct for the process and place is into @secid. 576 * @task_setgroups: 577 * Check permission before setting the supplementary group set of the 578 * current process. 579 * @group_info contains the new group information. 580 * Return 0 if permission is granted. 581 * @task_setnice: 582 * Check permission before setting the nice value of @p to @nice. 583 * @p contains the task_struct of process. 584 * @nice contains the new nice value. 585 * Return 0 if permission is granted. 586 * @task_setioprio 587 * Check permission before setting the ioprio value of @p to @ioprio. 588 * @p contains the task_struct of process. 589 * @ioprio contains the new ioprio value 590 * Return 0 if permission is granted. 591 * @task_getioprio 592 * Check permission before getting the ioprio value of @p. 593 * @p contains the task_struct of process. 594 * Return 0 if permission is granted. 595 * @task_setrlimit: 596 * Check permission before setting the resource limits of the current 597 * process for @resource to @new_rlim. The old resource limit values can 598 * be examined by dereferencing (current->signal->rlim + resource). 599 * @resource contains the resource whose limit is being set. 600 * @new_rlim contains the new limits for @resource. 601 * Return 0 if permission is granted. 602 * @task_setscheduler: 603 * Check permission before setting scheduling policy and/or parameters of 604 * process @p based on @policy and @lp. 605 * @p contains the task_struct for process. 606 * @policy contains the scheduling policy. 607 * @lp contains the scheduling parameters. 608 * Return 0 if permission is granted. 609 * @task_getscheduler: 610 * Check permission before obtaining scheduling information for process 611 * @p. 612 * @p contains the task_struct for process. 613 * Return 0 if permission is granted. 614 * @task_movememory 615 * Check permission before moving memory owned by process @p. 616 * @p contains the task_struct for process. 617 * Return 0 if permission is granted. 618 * @task_kill: 619 * Check permission before sending signal @sig to @p. @info can be NULL, 620 * the constant 1, or a pointer to a siginfo structure. If @info is 1 or 621 * SI_FROMKERNEL(info) is true, then the signal should be viewed as coming 622 * from the kernel and should typically be permitted. 623 * SIGIO signals are handled separately by the send_sigiotask hook in 624 * file_security_ops. 625 * @p contains the task_struct for process. 626 * @info contains the signal information. 627 * @sig contains the signal value. 628 * @secid contains the sid of the process where the signal originated 629 * Return 0 if permission is granted. 630 * @task_wait: 631 * Check permission before allowing a process to reap a child process @p 632 * and collect its status information. 633 * @p contains the task_struct for process. 634 * Return 0 if permission is granted. 635 * @task_prctl: 636 * Check permission before performing a process control operation on the 637 * current process. 638 * @option contains the operation. 639 * @arg2 contains a argument. 640 * @arg3 contains a argument. 641 * @arg4 contains a argument. 642 * @arg5 contains a argument. 643 * Return 0 if permission is granted. 644 * @task_reparent_to_init: 645 * Set the security attributes in @p->security for a kernel thread that 646 * is being reparented to the init task. 647 * @p contains the task_struct for the kernel thread. 648 * @task_to_inode: 649 * Set the security attributes for an inode based on an associated task's 650 * security attributes, e.g. for /proc/pid inodes. 651 * @p contains the task_struct for the task. 652 * @inode contains the inode structure for the inode. 653 * 654 * Security hooks for Netlink messaging. 655 * 656 * @netlink_send: 657 * Save security information for a netlink message so that permission 658 * checking can be performed when the message is processed. The security 659 * information can be saved using the eff_cap field of the 660 * netlink_skb_parms structure. Also may be used to provide fine 661 * grained control over message transmission. 662 * @sk associated sock of task sending the message., 663 * @skb contains the sk_buff structure for the netlink message. 664 * Return 0 if the information was successfully saved and message 665 * is allowed to be transmitted. 666 * @netlink_recv: 667 * Check permission before processing the received netlink message in 668 * @skb. 669 * @skb contains the sk_buff structure for the netlink message. 670 * @cap indicates the capability required 671 * Return 0 if permission is granted. 672 * 673 * Security hooks for Unix domain networking. 674 * 675 * @unix_stream_connect: 676 * Check permissions before establishing a Unix domain stream connection 677 * between @sock and @other. 678 * @sock contains the socket structure. 679 * @other contains the peer socket structure. 680 * Return 0 if permission is granted. 681 * @unix_may_send: 682 * Check permissions before connecting or sending datagrams from @sock to 683 * @other. 684 * @sock contains the socket structure. 685 * @sock contains the peer socket structure. 686 * Return 0 if permission is granted. 687 * 688 * The @unix_stream_connect and @unix_may_send hooks were necessary because 689 * Linux provides an alternative to the conventional file name space for Unix 690 * domain sockets. Whereas binding and connecting to sockets in the file name 691 * space is mediated by the typical file permissions (and caught by the mknod 692 * and permission hooks in inode_security_ops), binding and connecting to 693 * sockets in the abstract name space is completely unmediated. Sufficient 694 * control of Unix domain sockets in the abstract name space isn't possible 695 * using only the socket layer hooks, since we need to know the actual target 696 * socket, which is not looked up until we are inside the af_unix code. 697 * 698 * Security hooks for socket operations. 699 * 700 * @socket_create: 701 * Check permissions prior to creating a new socket. 702 * @family contains the requested protocol family. 703 * @type contains the requested communications type. 704 * @protocol contains the requested protocol. 705 * @kern set to 1 if a kernel socket. 706 * Return 0 if permission is granted. 707 * @socket_post_create: 708 * This hook allows a module to update or allocate a per-socket security 709 * structure. Note that the security field was not added directly to the 710 * socket structure, but rather, the socket security information is stored 711 * in the associated inode. Typically, the inode alloc_security hook will 712 * allocate and and attach security information to 713 * sock->inode->i_security. This hook may be used to update the 714 * sock->inode->i_security field with additional information that wasn't 715 * available when the inode was allocated. 716 * @sock contains the newly created socket structure. 717 * @family contains the requested protocol family. 718 * @type contains the requested communications type. 719 * @protocol contains the requested protocol. 720 * @kern set to 1 if a kernel socket. 721 * @socket_bind: 722 * Check permission before socket protocol layer bind operation is 723 * performed and the socket @sock is bound to the address specified in the 724 * @address parameter. 725 * @sock contains the socket structure. 726 * @address contains the address to bind to. 727 * @addrlen contains the length of address. 728 * Return 0 if permission is granted. 729 * @socket_connect: 730 * Check permission before socket protocol layer connect operation 731 * attempts to connect socket @sock to a remote address, @address. 732 * @sock contains the socket structure. 733 * @address contains the address of remote endpoint. 734 * @addrlen contains the length of address. 735 * Return 0 if permission is granted. 736 * @socket_listen: 737 * Check permission before socket protocol layer listen operation. 738 * @sock contains the socket structure. 739 * @backlog contains the maximum length for the pending connection queue. 740 * Return 0 if permission is granted. 741 * @socket_accept: 742 * Check permission before accepting a new connection. Note that the new 743 * socket, @newsock, has been created and some information copied to it, 744 * but the accept operation has not actually been performed. 745 * @sock contains the listening socket structure. 746 * @newsock contains the newly created server socket for connection. 747 * Return 0 if permission is granted. 748 * @socket_post_accept: 749 * This hook allows a security module to copy security 750 * information into the newly created socket's inode. 751 * @sock contains the listening socket structure. 752 * @newsock contains the newly created server socket for connection. 753 * @socket_sendmsg: 754 * Check permission before transmitting a message to another socket. 755 * @sock contains the socket structure. 756 * @msg contains the message to be transmitted. 757 * @size contains the size of message. 758 * Return 0 if permission is granted. 759 * @socket_recvmsg: 760 * Check permission before receiving a message from a socket. 761 * @sock contains the socket structure. 762 * @msg contains the message structure. 763 * @size contains the size of message structure. 764 * @flags contains the operational flags. 765 * Return 0 if permission is granted. 766 * @socket_getsockname: 767 * Check permission before the local address (name) of the socket object 768 * @sock is retrieved. 769 * @sock contains the socket structure. 770 * Return 0 if permission is granted. 771 * @socket_getpeername: 772 * Check permission before the remote address (name) of a socket object 773 * @sock is retrieved. 774 * @sock contains the socket structure. 775 * Return 0 if permission is granted. 776 * @socket_getsockopt: 777 * Check permissions before retrieving the options associated with socket 778 * @sock. 779 * @sock contains the socket structure. 780 * @level contains the protocol level to retrieve option from. 781 * @optname contains the name of option to retrieve. 782 * Return 0 if permission is granted. 783 * @socket_setsockopt: 784 * Check permissions before setting the options associated with socket 785 * @sock. 786 * @sock contains the socket structure. 787 * @level contains the protocol level to set options for. 788 * @optname contains the name of the option to set. 789 * Return 0 if permission is granted. 790 * @socket_shutdown: 791 * Checks permission before all or part of a connection on the socket 792 * @sock is shut down. 793 * @sock contains the socket structure. 794 * @how contains the flag indicating how future sends and receives are handled. 795 * Return 0 if permission is granted. 796 * @socket_sock_rcv_skb: 797 * Check permissions on incoming network packets. This hook is distinct 798 * from Netfilter's IP input hooks since it is the first time that the 799 * incoming sk_buff @skb has been associated with a particular socket, @sk. 800 * @sk contains the sock (not socket) associated with the incoming sk_buff. 801 * @skb contains the incoming network data. 802 * @socket_getpeersec: 803 * This hook allows the security module to provide peer socket security 804 * state to userspace via getsockopt SO_GETPEERSEC. 805 * @sock is the local socket. 806 * @optval userspace memory where the security state is to be copied. 807 * @optlen userspace int where the module should copy the actual length 808 * of the security state. 809 * @len as input is the maximum length to copy to userspace provided 810 * by the caller. 811 * Return 0 if all is well, otherwise, typical getsockopt return 812 * values. 813 * @sk_alloc_security: 814 * Allocate and attach a security structure to the sk->sk_security field, 815 * which is used to copy security attributes between local stream sockets. 816 * @sk_free_security: 817 * Deallocate security structure. 818 * @sk_clone_security: 819 * Clone/copy security structure. 820 * @sk_getsecid: 821 * Retrieve the LSM-specific secid for the sock to enable caching of network 822 * authorizations. 823 * @sock_graft: 824 * Sets the socket's isec sid to the sock's sid. 825 * @inet_conn_request: 826 * Sets the openreq's sid to socket's sid with MLS portion taken from peer sid. 827 * @inet_csk_clone: 828 * Sets the new child socket's sid to the openreq sid. 829 * @inet_conn_established: 830 * Sets the connection's peersid to the secmark on skb. 831 * @req_classify_flow: 832 * Sets the flow's sid to the openreq sid. 833 * 834 * Security hooks for XFRM operations. 835 * 836 * @xfrm_policy_alloc_security: 837 * @xp contains the xfrm_policy being added to Security Policy Database 838 * used by the XFRM system. 839 * @sec_ctx contains the security context information being provided by 840 * the user-level policy update program (e.g., setkey). 841 * Allocate a security structure to the xp->security field; the security 842 * field is initialized to NULL when the xfrm_policy is allocated. 843 * Return 0 if operation was successful (memory to allocate, legal context) 844 * @xfrm_policy_clone_security: 845 * @old contains an existing xfrm_policy in the SPD. 846 * @new contains a new xfrm_policy being cloned from old. 847 * Allocate a security structure to the new->security field 848 * that contains the information from the old->security field. 849 * Return 0 if operation was successful (memory to allocate). 850 * @xfrm_policy_free_security: 851 * @xp contains the xfrm_policy 852 * Deallocate xp->security. 853 * @xfrm_policy_delete_security: 854 * @xp contains the xfrm_policy. 855 * Authorize deletion of xp->security. 856 * @xfrm_state_alloc_security: 857 * @x contains the xfrm_state being added to the Security Association 858 * Database by the XFRM system. 859 * @sec_ctx contains the security context information being provided by 860 * the user-level SA generation program (e.g., setkey or racoon). 861 * @secid contains the secid from which to take the mls portion of the context. 862 * Allocate a security structure to the x->security field; the security 863 * field is initialized to NULL when the xfrm_state is allocated. Set the 864 * context to correspond to either sec_ctx or polsec, with the mls portion 865 * taken from secid in the latter case. 866 * Return 0 if operation was successful (memory to allocate, legal context). 867 * @xfrm_state_free_security: 868 * @x contains the xfrm_state. 869 * Deallocate x->security. 870 * @xfrm_state_delete_security: 871 * @x contains the xfrm_state. 872 * Authorize deletion of x->security. 873 * @xfrm_policy_lookup: 874 * @xp contains the xfrm_policy for which the access control is being 875 * checked. 876 * @fl_secid contains the flow security label that is used to authorize 877 * access to the policy xp. 878 * @dir contains the direction of the flow (input or output). 879 * Check permission when a flow selects a xfrm_policy for processing 880 * XFRMs on a packet. The hook is called when selecting either a 881 * per-socket policy or a generic xfrm policy. 882 * Return 0 if permission is granted, -ESRCH otherwise, or -errno 883 * on other errors. 884 * @xfrm_state_pol_flow_match: 885 * @x contains the state to match. 886 * @xp contains the policy to check for a match. 887 * @fl contains the flow to check for a match. 888 * Return 1 if there is a match. 889 * @xfrm_decode_session: 890 * @skb points to skb to decode. 891 * @secid points to the flow key secid to set. 892 * @ckall says if all xfrms used should be checked for same secid. 893 * Return 0 if ckall is zero or all xfrms used have the same secid. 894 * 895 * Security hooks affecting all Key Management operations 896 * 897 * @key_alloc: 898 * Permit allocation of a key and assign security data. Note that key does 899 * not have a serial number assigned at this point. 900 * @key points to the key. 901 * @flags is the allocation flags 902 * Return 0 if permission is granted, -ve error otherwise. 903 * @key_free: 904 * Notification of destruction; free security data. 905 * @key points to the key. 906 * No return value. 907 * @key_permission: 908 * See whether a specific operational right is granted to a process on a 909 * key. 910 * @key_ref refers to the key (key pointer + possession attribute bit). 911 * @context points to the process to provide the context against which to 912 * evaluate the security data on the key. 913 * @perm describes the combination of permissions required of this key. 914 * Return 1 if permission granted, 0 if permission denied and -ve it the 915 * normal permissions model should be effected. 916 * 917 * Security hooks affecting all System V IPC operations. 918 * 919 * @ipc_permission: 920 * Check permissions for access to IPC 921 * @ipcp contains the kernel IPC permission structure 922 * @flag contains the desired (requested) permission set 923 * Return 0 if permission is granted. 924 * 925 * Security hooks for individual messages held in System V IPC message queues 926 * @msg_msg_alloc_security: 927 * Allocate and attach a security structure to the msg->security field. 928 * The security field is initialized to NULL when the structure is first 929 * created. 930 * @msg contains the message structure to be modified. 931 * Return 0 if operation was successful and permission is granted. 932 * @msg_msg_free_security: 933 * Deallocate the security structure for this message. 934 * @msg contains the message structure to be modified. 935 * 936 * Security hooks for System V IPC Message Queues 937 * 938 * @msg_queue_alloc_security: 939 * Allocate and attach a security structure to the 940 * msq->q_perm.security field. The security field is initialized to 941 * NULL when the structure is first created. 942 * @msq contains the message queue structure to be modified. 943 * Return 0 if operation was successful and permission is granted. 944 * @msg_queue_free_security: 945 * Deallocate security structure for this message queue. 946 * @msq contains the message queue structure to be modified. 947 * @msg_queue_associate: 948 * Check permission when a message queue is requested through the 949 * msgget system call. This hook is only called when returning the 950 * message queue identifier for an existing message queue, not when a 951 * new message queue is created. 952 * @msq contains the message queue to act upon. 953 * @msqflg contains the operation control flags. 954 * Return 0 if permission is granted. 955 * @msg_queue_msgctl: 956 * Check permission when a message control operation specified by @cmd 957 * is to be performed on the message queue @msq. 958 * The @msq may be NULL, e.g. for IPC_INFO or MSG_INFO. 959 * @msq contains the message queue to act upon. May be NULL. 960 * @cmd contains the operation to be performed. 961 * Return 0 if permission is granted. 962 * @msg_queue_msgsnd: 963 * Check permission before a message, @msg, is enqueued on the message 964 * queue, @msq. 965 * @msq contains the message queue to send message to. 966 * @msg contains the message to be enqueued. 967 * @msqflg contains operational flags. 968 * Return 0 if permission is granted. 969 * @msg_queue_msgrcv: 970 * Check permission before a message, @msg, is removed from the message 971 * queue, @msq. The @target task structure contains a pointer to the 972 * process that will be receiving the message (not equal to the current 973 * process when inline receives are being performed). 974 * @msq contains the message queue to retrieve message from. 975 * @msg contains the message destination. 976 * @target contains the task structure for recipient process. 977 * @type contains the type of message requested. 978 * @mode contains the operational flags. 979 * Return 0 if permission is granted. 980 * 981 * Security hooks for System V Shared Memory Segments 982 * 983 * @shm_alloc_security: 984 * Allocate and attach a security structure to the shp->shm_perm.security 985 * field. The security field is initialized to NULL when the structure is 986 * first created. 987 * @shp contains the shared memory structure to be modified. 988 * Return 0 if operation was successful and permission is granted. 989 * @shm_free_security: 990 * Deallocate the security struct for this memory segment. 991 * @shp contains the shared memory structure to be modified. 992 * @shm_associate: 993 * Check permission when a shared memory region is requested through the 994 * shmget system call. This hook is only called when returning the shared 995 * memory region identifier for an existing region, not when a new shared 996 * memory region is created. 997 * @shp contains the shared memory structure to be modified. 998 * @shmflg contains the operation control flags. 999 * Return 0 if permission is granted. 1000 * @shm_shmctl: 1001 * Check permission when a shared memory control operation specified by 1002 * @cmd is to be performed on the shared memory region @shp. 1003 * The @shp may be NULL, e.g. for IPC_INFO or SHM_INFO. 1004 * @shp contains shared memory structure to be modified. 1005 * @cmd contains the operation to be performed. 1006 * Return 0 if permission is granted. 1007 * @shm_shmat: 1008 * Check permissions prior to allowing the shmat system call to attach the 1009 * shared memory segment @shp to the data segment of the calling process. 1010 * The attaching address is specified by @shmaddr. 1011 * @shp contains the shared memory structure to be modified. 1012 * @shmaddr contains the address to attach memory region to. 1013 * @shmflg contains the operational flags. 1014 * Return 0 if permission is granted. 1015 * 1016 * Security hooks for System V Semaphores 1017 * 1018 * @sem_alloc_security: 1019 * Allocate and attach a security structure to the sma->sem_perm.security 1020 * field. The security field is initialized to NULL when the structure is 1021 * first created. 1022 * @sma contains the semaphore structure 1023 * Return 0 if operation was successful and permission is granted. 1024 * @sem_free_security: 1025 * deallocate security struct for this semaphore 1026 * @sma contains the semaphore structure. 1027 * @sem_associate: 1028 * Check permission when a semaphore is requested through the semget 1029 * system call. This hook is only called when returning the semaphore 1030 * identifier for an existing semaphore, not when a new one must be 1031 * created. 1032 * @sma contains the semaphore structure. 1033 * @semflg contains the operation control flags. 1034 * Return 0 if permission is granted. 1035 * @sem_semctl: 1036 * Check permission when a semaphore operation specified by @cmd is to be 1037 * performed on the semaphore @sma. The @sma may be NULL, e.g. for 1038 * IPC_INFO or SEM_INFO. 1039 * @sma contains the semaphore structure. May be NULL. 1040 * @cmd contains the operation to be performed. 1041 * Return 0 if permission is granted. 1042 * @sem_semop 1043 * Check permissions before performing operations on members of the 1044 * semaphore set @sma. If the @alter flag is nonzero, the semaphore set 1045 * may be modified. 1046 * @sma contains the semaphore structure. 1047 * @sops contains the operations to perform. 1048 * @nsops contains the number of operations to perform. 1049 * @alter contains the flag indicating whether changes are to be made. 1050 * Return 0 if permission is granted. 1051 * 1052 * @ptrace: 1053 * Check permission before allowing the @parent process to trace the 1054 * @child process. 1055 * Security modules may also want to perform a process tracing check 1056 * during an execve in the set_security or apply_creds hooks of 1057 * binprm_security_ops if the process is being traced and its security 1058 * attributes would be changed by the execve. 1059 * @parent contains the task_struct structure for parent process. 1060 * @child contains the task_struct structure for child process. 1061 * Return 0 if permission is granted. 1062 * @capget: 1063 * Get the @effective, @inheritable, and @permitted capability sets for 1064 * the @target process. The hook may also perform permission checking to 1065 * determine if the current process is allowed to see the capability sets 1066 * of the @target process. 1067 * @target contains the task_struct structure for target process. 1068 * @effective contains the effective capability set. 1069 * @inheritable contains the inheritable capability set. 1070 * @permitted contains the permitted capability set. 1071 * Return 0 if the capability sets were successfully obtained. 1072 * @capset_check: 1073 * Check permission before setting the @effective, @inheritable, and 1074 * @permitted capability sets for the @target process. 1075 * Caveat: @target is also set to current if a set of processes is 1076 * specified (i.e. all processes other than current and init or a 1077 * particular process group). Hence, the capset_set hook may need to 1078 * revalidate permission to the actual target process. 1079 * @target contains the task_struct structure for target process. 1080 * @effective contains the effective capability set. 1081 * @inheritable contains the inheritable capability set. 1082 * @permitted contains the permitted capability set. 1083 * Return 0 if permission is granted. 1084 * @capset_set: 1085 * Set the @effective, @inheritable, and @permitted capability sets for 1086 * the @target process. Since capset_check cannot always check permission 1087 * to the real @target process, this hook may also perform permission 1088 * checking to determine if the current process is allowed to set the 1089 * capability sets of the @target process. However, this hook has no way 1090 * of returning an error due to the structure of the sys_capset code. 1091 * @target contains the task_struct structure for target process. 1092 * @effective contains the effective capability set. 1093 * @inheritable contains the inheritable capability set. 1094 * @permitted contains the permitted capability set. 1095 * @capable: 1096 * Check whether the @tsk process has the @cap capability. 1097 * @tsk contains the task_struct for the process. 1098 * @cap contains the capability <include/linux/capability.h>. 1099 * Return 0 if the capability is granted for @tsk. 1100 * @acct: 1101 * Check permission before enabling or disabling process accounting. If 1102 * accounting is being enabled, then @file refers to the open file used to 1103 * store accounting records. If accounting is being disabled, then @file 1104 * is NULL. 1105 * @file contains the file structure for the accounting file (may be NULL). 1106 * Return 0 if permission is granted. 1107 * @sysctl: 1108 * Check permission before accessing the @table sysctl variable in the 1109 * manner specified by @op. 1110 * @table contains the ctl_table structure for the sysctl variable. 1111 * @op contains the operation (001 = search, 002 = write, 004 = read). 1112 * Return 0 if permission is granted. 1113 * @syslog: 1114 * Check permission before accessing the kernel message ring or changing 1115 * logging to the console. 1116 * See the syslog(2) manual page for an explanation of the @type values. 1117 * @type contains the type of action. 1118 * Return 0 if permission is granted. 1119 * @settime: 1120 * Check permission to change the system time. 1121 * struct timespec and timezone are defined in include/linux/time.h 1122 * @ts contains new time 1123 * @tz contains new timezone 1124 * Return 0 if permission is granted. 1125 * @vm_enough_memory: 1126 * Check permissions for allocating a new virtual mapping. 1127 * @pages contains the number of pages. 1128 * Return 0 if permission is granted. 1129 * 1130 * @register_security: 1131 * allow module stacking. 1132 * @name contains the name of the security module being stacked. 1133 * @ops contains a pointer to the struct security_operations of the module to stack. 1134 * @unregister_security: 1135 * remove a stacked module. 1136 * @name contains the name of the security module being unstacked. 1137 * @ops contains a pointer to the struct security_operations of the module to unstack. 1138 * 1139 * @secid_to_secctx: 1140 * Convert secid to security context. 1141 * @secid contains the security ID. 1142 * @secdata contains the pointer that stores the converted security context. 1143 * 1144 * @release_secctx: 1145 * Release the security context. 1146 * @secdata contains the security context. 1147 * @seclen contains the length of the security context. 1148 * 1149 * This is the main security structure. 1150 */ 1151struct security_operations { 1152 int (*ptrace) (struct task_struct * parent, struct task_struct * child); 1153 int (*capget) (struct task_struct * target, 1154 kernel_cap_t * effective, 1155 kernel_cap_t * inheritable, kernel_cap_t * permitted); 1156 int (*capset_check) (struct task_struct * target, 1157 kernel_cap_t * effective, 1158 kernel_cap_t * inheritable, 1159 kernel_cap_t * permitted); 1160 void (*capset_set) (struct task_struct * target, 1161 kernel_cap_t * effective, 1162 kernel_cap_t * inheritable, 1163 kernel_cap_t * permitted); 1164 int (*capable) (struct task_struct * tsk, int cap); 1165 int (*acct) (struct file * file); 1166 int (*sysctl) (struct ctl_table * table, int op); 1167 int (*quotactl) (int cmds, int type, int id, struct super_block * sb); 1168 int (*quota_on) (struct dentry * dentry); 1169 int (*syslog) (int type); 1170 int (*settime) (struct timespec *ts, struct timezone *tz); 1171 int (*vm_enough_memory) (long pages); 1172 1173 int (*bprm_alloc_security) (struct linux_binprm * bprm); 1174 void (*bprm_free_security) (struct linux_binprm * bprm); 1175 void (*bprm_apply_creds) (struct linux_binprm * bprm, int unsafe); 1176 void (*bprm_post_apply_creds) (struct linux_binprm * bprm); 1177 int (*bprm_set_security) (struct linux_binprm * bprm); 1178 int (*bprm_check_security) (struct linux_binprm * bprm); 1179 int (*bprm_secureexec) (struct linux_binprm * bprm); 1180 1181 int (*sb_alloc_security) (struct super_block * sb); 1182 void (*sb_free_security) (struct super_block * sb); 1183 int (*sb_copy_data)(struct file_system_type *type, 1184 void *orig, void *copy); 1185 int (*sb_kern_mount) (struct super_block *sb, void *data); 1186 int (*sb_statfs) (struct dentry *dentry); 1187 int (*sb_mount) (char *dev_name, struct nameidata * nd, 1188 char *type, unsigned long flags, void *data); 1189 int (*sb_check_sb) (struct vfsmount * mnt, struct nameidata * nd); 1190 int (*sb_umount) (struct vfsmount * mnt, int flags); 1191 void (*sb_umount_close) (struct vfsmount * mnt); 1192 void (*sb_umount_busy) (struct vfsmount * mnt); 1193 void (*sb_post_remount) (struct vfsmount * mnt, 1194 unsigned long flags, void *data); 1195 void (*sb_post_mountroot) (void); 1196 void (*sb_post_addmount) (struct vfsmount * mnt, 1197 struct nameidata * mountpoint_nd); 1198 int (*sb_pivotroot) (struct nameidata * old_nd, 1199 struct nameidata * new_nd); 1200 void (*sb_post_pivotroot) (struct nameidata * old_nd, 1201 struct nameidata * new_nd); 1202 1203 int (*inode_alloc_security) (struct inode *inode); 1204 void (*inode_free_security) (struct inode *inode); 1205 int (*inode_init_security) (struct inode *inode, struct inode *dir, 1206 char **name, void **value, size_t *len); 1207 int (*inode_create) (struct inode *dir, 1208 struct dentry *dentry, int mode); 1209 int (*inode_link) (struct dentry *old_dentry, 1210 struct inode *dir, struct dentry *new_dentry); 1211 int (*inode_unlink) (struct inode *dir, struct dentry *dentry); 1212 int (*inode_symlink) (struct inode *dir, 1213 struct dentry *dentry, const char *old_name); 1214 int (*inode_mkdir) (struct inode *dir, struct dentry *dentry, int mode); 1215 int (*inode_rmdir) (struct inode *dir, struct dentry *dentry); 1216 int (*inode_mknod) (struct inode *dir, struct dentry *dentry, 1217 int mode, dev_t dev); 1218 int (*inode_rename) (struct inode *old_dir, struct dentry *old_dentry, 1219 struct inode *new_dir, struct dentry *new_dentry); 1220 int (*inode_readlink) (struct dentry *dentry); 1221 int (*inode_follow_link) (struct dentry *dentry, struct nameidata *nd); 1222 int (*inode_permission) (struct inode *inode, int mask, struct nameidata *nd); 1223 int (*inode_setattr) (struct dentry *dentry, struct iattr *attr); 1224 int (*inode_getattr) (struct vfsmount *mnt, struct dentry *dentry); 1225 void (*inode_delete) (struct inode *inode); 1226 int (*inode_setxattr) (struct dentry *dentry, char *name, void *value, 1227 size_t size, int flags); 1228 void (*inode_post_setxattr) (struct dentry *dentry, char *name, void *value, 1229 size_t size, int flags); 1230 int (*inode_getxattr) (struct dentry *dentry, char *name); 1231 int (*inode_listxattr) (struct dentry *dentry); 1232 int (*inode_removexattr) (struct dentry *dentry, char *name); 1233 const char *(*inode_xattr_getsuffix) (void); 1234 int (*inode_getsecurity)(const struct inode *inode, const char *name, void *buffer, size_t size, int err); 1235 int (*inode_setsecurity)(struct inode *inode, const char *name, const void *value, size_t size, int flags); 1236 int (*inode_listsecurity)(struct inode *inode, char *buffer, size_t buffer_size); 1237 1238 int (*file_permission) (struct file * file, int mask); 1239 int (*file_alloc_security) (struct file * file); 1240 void (*file_free_security) (struct file * file); 1241 int (*file_ioctl) (struct file * file, unsigned int cmd, 1242 unsigned long arg); 1243 int (*file_mmap) (struct file * file, 1244 unsigned long reqprot, 1245 unsigned long prot, unsigned long flags); 1246 int (*file_mprotect) (struct vm_area_struct * vma, 1247 unsigned long reqprot, 1248 unsigned long prot); 1249 int (*file_lock) (struct file * file, unsigned int cmd); 1250 int (*file_fcntl) (struct file * file, unsigned int cmd, 1251 unsigned long arg); 1252 int (*file_set_fowner) (struct file * file); 1253 int (*file_send_sigiotask) (struct task_struct * tsk, 1254 struct fown_struct * fown, int sig); 1255 int (*file_receive) (struct file * file); 1256 1257 int (*task_create) (unsigned long clone_flags); 1258 int (*task_alloc_security) (struct task_struct * p); 1259 void (*task_free_security) (struct task_struct * p); 1260 int (*task_setuid) (uid_t id0, uid_t id1, uid_t id2, int flags); 1261 int (*task_post_setuid) (uid_t old_ruid /* or fsuid */ , 1262 uid_t old_euid, uid_t old_suid, int flags); 1263 int (*task_setgid) (gid_t id0, gid_t id1, gid_t id2, int flags); 1264 int (*task_setpgid) (struct task_struct * p, pid_t pgid); 1265 int (*task_getpgid) (struct task_struct * p); 1266 int (*task_getsid) (struct task_struct * p); 1267 void (*task_getsecid) (struct task_struct * p, u32 * secid); 1268 int (*task_setgroups) (struct group_info *group_info); 1269 int (*task_setnice) (struct task_struct * p, int nice); 1270 int (*task_setioprio) (struct task_struct * p, int ioprio); 1271 int (*task_getioprio) (struct task_struct * p); 1272 int (*task_setrlimit) (unsigned int resource, struct rlimit * new_rlim); 1273 int (*task_setscheduler) (struct task_struct * p, int policy, 1274 struct sched_param * lp); 1275 int (*task_getscheduler) (struct task_struct * p); 1276 int (*task_movememory) (struct task_struct * p); 1277 int (*task_kill) (struct task_struct * p, 1278 struct siginfo * info, int sig, u32 secid); 1279 int (*task_wait) (struct task_struct * p); 1280 int (*task_prctl) (int option, unsigned long arg2, 1281 unsigned long arg3, unsigned long arg4, 1282 unsigned long arg5); 1283 void (*task_reparent_to_init) (struct task_struct * p); 1284 void (*task_to_inode)(struct task_struct *p, struct inode *inode); 1285 1286 int (*ipc_permission) (struct kern_ipc_perm * ipcp, short flag); 1287 1288 int (*msg_msg_alloc_security) (struct msg_msg * msg); 1289 void (*msg_msg_free_security) (struct msg_msg * msg); 1290 1291 int (*msg_queue_alloc_security) (struct msg_queue * msq); 1292 void (*msg_queue_free_security) (struct msg_queue * msq); 1293 int (*msg_queue_associate) (struct msg_queue * msq, int msqflg); 1294 int (*msg_queue_msgctl) (struct msg_queue * msq, int cmd); 1295 int (*msg_queue_msgsnd) (struct msg_queue * msq, 1296 struct msg_msg * msg, int msqflg); 1297 int (*msg_queue_msgrcv) (struct msg_queue * msq, 1298 struct msg_msg * msg, 1299 struct task_struct * target, 1300 long type, int mode); 1301 1302 int (*shm_alloc_security) (struct shmid_kernel * shp); 1303 void (*shm_free_security) (struct shmid_kernel * shp); 1304 int (*shm_associate) (struct shmid_kernel * shp, int shmflg); 1305 int (*shm_shmctl) (struct shmid_kernel * shp, int cmd); 1306 int (*shm_shmat) (struct shmid_kernel * shp, 1307 char __user *shmaddr, int shmflg); 1308 1309 int (*sem_alloc_security) (struct sem_array * sma); 1310 void (*sem_free_security) (struct sem_array * sma); 1311 int (*sem_associate) (struct sem_array * sma, int semflg); 1312 int (*sem_semctl) (struct sem_array * sma, int cmd); 1313 int (*sem_semop) (struct sem_array * sma, 1314 struct sembuf * sops, unsigned nsops, int alter); 1315 1316 int (*netlink_send) (struct sock * sk, struct sk_buff * skb); 1317 int (*netlink_recv) (struct sk_buff * skb, int cap); 1318 1319 /* allow module stacking */ 1320 int (*register_security) (const char *name, 1321 struct security_operations *ops); 1322 int (*unregister_security) (const char *name, 1323 struct security_operations *ops); 1324 1325 void (*d_instantiate) (struct dentry *dentry, struct inode *inode); 1326 1327 int (*getprocattr)(struct task_struct *p, char *name, char **value); 1328 int (*setprocattr)(struct task_struct *p, char *name, void *value, size_t size); 1329 int (*secid_to_secctx)(u32 secid, char **secdata, u32 *seclen); 1330 void (*release_secctx)(char *secdata, u32 seclen); 1331 1332#ifdef CONFIG_SECURITY_NETWORK 1333 int (*unix_stream_connect) (struct socket * sock, 1334 struct socket * other, struct sock * newsk); 1335 int (*unix_may_send) (struct socket * sock, struct socket * other); 1336 1337 int (*socket_create) (int family, int type, int protocol, int kern); 1338 int (*socket_post_create) (struct socket * sock, int family, 1339 int type, int protocol, int kern); 1340 int (*socket_bind) (struct socket * sock, 1341 struct sockaddr * address, int addrlen); 1342 int (*socket_connect) (struct socket * sock, 1343 struct sockaddr * address, int addrlen); 1344 int (*socket_listen) (struct socket * sock, int backlog); 1345 int (*socket_accept) (struct socket * sock, struct socket * newsock); 1346 void (*socket_post_accept) (struct socket * sock, 1347 struct socket * newsock); 1348 int (*socket_sendmsg) (struct socket * sock, 1349 struct msghdr * msg, int size); 1350 int (*socket_recvmsg) (struct socket * sock, 1351 struct msghdr * msg, int size, int flags); 1352 int (*socket_getsockname) (struct socket * sock); 1353 int (*socket_getpeername) (struct socket * sock); 1354 int (*socket_getsockopt) (struct socket * sock, int level, int optname); 1355 int (*socket_setsockopt) (struct socket * sock, int level, int optname); 1356 int (*socket_shutdown) (struct socket * sock, int how); 1357 int (*socket_sock_rcv_skb) (struct sock * sk, struct sk_buff * skb); 1358 int (*socket_getpeersec_stream) (struct socket *sock, char __user *optval, int __user *optlen, unsigned len); 1359 int (*socket_getpeersec_dgram) (struct socket *sock, struct sk_buff *skb, u32 *secid); 1360 int (*sk_alloc_security) (struct sock *sk, int family, gfp_t priority); 1361 void (*sk_free_security) (struct sock *sk); 1362 void (*sk_clone_security) (const struct sock *sk, struct sock *newsk); 1363 void (*sk_getsecid) (struct sock *sk, u32 *secid); 1364 void (*sock_graft)(struct sock* sk, struct socket *parent); 1365 int (*inet_conn_request)(struct sock *sk, struct sk_buff *skb, 1366 struct request_sock *req); 1367 void (*inet_csk_clone)(struct sock *newsk, const struct request_sock *req); 1368 void (*inet_conn_established)(struct sock *sk, struct sk_buff *skb); 1369 void (*req_classify_flow)(const struct request_sock *req, struct flowi *fl); 1370#endif /* CONFIG_SECURITY_NETWORK */ 1371 1372#ifdef CONFIG_SECURITY_NETWORK_XFRM 1373 int (*xfrm_policy_alloc_security) (struct xfrm_policy *xp, 1374 struct xfrm_user_sec_ctx *sec_ctx); 1375 int (*xfrm_policy_clone_security) (struct xfrm_policy *old, struct xfrm_policy *new); 1376 void (*xfrm_policy_free_security) (struct xfrm_policy *xp); 1377 int (*xfrm_policy_delete_security) (struct xfrm_policy *xp); 1378 int (*xfrm_state_alloc_security) (struct xfrm_state *x, 1379 struct xfrm_user_sec_ctx *sec_ctx, 1380 u32 secid); 1381 void (*xfrm_state_free_security) (struct xfrm_state *x); 1382 int (*xfrm_state_delete_security) (struct xfrm_state *x); 1383 int (*xfrm_policy_lookup)(struct xfrm_policy *xp, u32 fl_secid, u8 dir); 1384 int (*xfrm_state_pol_flow_match)(struct xfrm_state *x, 1385 struct xfrm_policy *xp, struct flowi *fl); 1386 int (*xfrm_decode_session)(struct sk_buff *skb, u32 *secid, int ckall); 1387#endif /* CONFIG_SECURITY_NETWORK_XFRM */ 1388 1389 /* key management security hooks */ 1390#ifdef CONFIG_KEYS 1391 int (*key_alloc)(struct key *key, struct task_struct *tsk, unsigned long flags); 1392 void (*key_free)(struct key *key); 1393 int (*key_permission)(key_ref_t key_ref, 1394 struct task_struct *context, 1395 key_perm_t perm); 1396 1397#endif /* CONFIG_KEYS */ 1398 1399}; 1400 1401/* global variables */ 1402extern struct security_operations *security_ops; 1403 1404/* inline stuff */ 1405static inline int security_ptrace (struct task_struct * parent, struct task_struct * child) 1406{ 1407 return security_ops->ptrace (parent, child); 1408} 1409 1410static inline int security_capget (struct task_struct *target, 1411 kernel_cap_t *effective, 1412 kernel_cap_t *inheritable, 1413 kernel_cap_t *permitted) 1414{ 1415 return security_ops->capget (target, effective, inheritable, permitted); 1416} 1417 1418static inline int security_capset_check (struct task_struct *target, 1419 kernel_cap_t *effective, 1420 kernel_cap_t *inheritable, 1421 kernel_cap_t *permitted) 1422{ 1423 return security_ops->capset_check (target, effective, inheritable, permitted); 1424} 1425 1426static inline void security_capset_set (struct task_struct *target, 1427 kernel_cap_t *effective, 1428 kernel_cap_t *inheritable, 1429 kernel_cap_t *permitted) 1430{ 1431 security_ops->capset_set (target, effective, inheritable, permitted); 1432} 1433 1434static inline int security_capable(struct task_struct *tsk, int cap) 1435{ 1436 return security_ops->capable(tsk, cap); 1437} 1438 1439static inline int security_acct (struct file *file) 1440{ 1441 return security_ops->acct (file); 1442} 1443 1444static inline int security_sysctl(struct ctl_table *table, int op) 1445{ 1446 return security_ops->sysctl(table, op); 1447} 1448 1449static inline int security_quotactl (int cmds, int type, int id, 1450 struct super_block *sb) 1451{ 1452 return security_ops->quotactl (cmds, type, id, sb); 1453} 1454 1455static inline int security_quota_on (struct dentry * dentry) 1456{ 1457 return security_ops->quota_on (dentry); 1458} 1459 1460static inline int security_syslog(int type) 1461{ 1462 return security_ops->syslog(type); 1463} 1464 1465static inline int security_settime(struct timespec *ts, struct timezone *tz) 1466{ 1467 return security_ops->settime(ts, tz); 1468} 1469 1470 1471static inline int security_vm_enough_memory(long pages) 1472{ 1473 return security_ops->vm_enough_memory(pages); 1474} 1475 1476static inline int security_bprm_alloc (struct linux_binprm *bprm) 1477{ 1478 return security_ops->bprm_alloc_security (bprm); 1479} 1480static inline void security_bprm_free (struct linux_binprm *bprm) 1481{ 1482 security_ops->bprm_free_security (bprm); 1483} 1484static inline void security_bprm_apply_creds (struct linux_binprm *bprm, int unsafe) 1485{ 1486 security_ops->bprm_apply_creds (bprm, unsafe); 1487} 1488static inline void security_bprm_post_apply_creds (struct linux_binprm *bprm) 1489{ 1490 security_ops->bprm_post_apply_creds (bprm); 1491} 1492static inline int security_bprm_set (struct linux_binprm *bprm) 1493{ 1494 return security_ops->bprm_set_security (bprm); 1495} 1496 1497static inline int security_bprm_check (struct linux_binprm *bprm) 1498{ 1499 return security_ops->bprm_check_security (bprm); 1500} 1501 1502static inline int security_bprm_secureexec (struct linux_binprm *bprm) 1503{ 1504 return security_ops->bprm_secureexec (bprm); 1505} 1506 1507static inline int security_sb_alloc (struct super_block *sb) 1508{ 1509 return security_ops->sb_alloc_security (sb); 1510} 1511 1512static inline void security_sb_free (struct super_block *sb) 1513{ 1514 security_ops->sb_free_security (sb); 1515} 1516 1517static inline int security_sb_copy_data (struct file_system_type *type, 1518 void *orig, void *copy) 1519{ 1520 return security_ops->sb_copy_data (type, orig, copy); 1521} 1522 1523static inline int security_sb_kern_mount (struct super_block *sb, void *data) 1524{ 1525 return security_ops->sb_kern_mount (sb, data); 1526} 1527 1528static inline int security_sb_statfs (struct dentry *dentry) 1529{ 1530 return security_ops->sb_statfs (dentry); 1531} 1532 1533static inline int security_sb_mount (char *dev_name, struct nameidata *nd, 1534 char *type, unsigned long flags, 1535 void *data) 1536{ 1537 return security_ops->sb_mount (dev_name, nd, type, flags, data); 1538} 1539 1540static inline int security_sb_check_sb (struct vfsmount *mnt, 1541 struct nameidata *nd) 1542{ 1543 return security_ops->sb_check_sb (mnt, nd); 1544} 1545 1546static inline int security_sb_umount (struct vfsmount *mnt, int flags) 1547{ 1548 return security_ops->sb_umount (mnt, flags); 1549} 1550 1551static inline void security_sb_umount_close (struct vfsmount *mnt) 1552{ 1553 security_ops->sb_umount_close (mnt); 1554} 1555 1556static inline void security_sb_umount_busy (struct vfsmount *mnt) 1557{ 1558 security_ops->sb_umount_busy (mnt); 1559} 1560 1561static inline void security_sb_post_remount (struct vfsmount *mnt, 1562 unsigned long flags, void *data) 1563{ 1564 security_ops->sb_post_remount (mnt, flags, data); 1565} 1566 1567static inline void security_sb_post_mountroot (void) 1568{ 1569 security_ops->sb_post_mountroot (); 1570} 1571 1572static inline void security_sb_post_addmount (struct vfsmount *mnt, 1573 struct nameidata *mountpoint_nd) 1574{ 1575 security_ops->sb_post_addmount (mnt, mountpoint_nd); 1576} 1577 1578static inline int security_sb_pivotroot (struct nameidata *old_nd, 1579 struct nameidata *new_nd) 1580{ 1581 return security_ops->sb_pivotroot (old_nd, new_nd); 1582} 1583 1584static inline void security_sb_post_pivotroot (struct nameidata *old_nd, 1585 struct nameidata *new_nd) 1586{ 1587 security_ops->sb_post_pivotroot (old_nd, new_nd); 1588} 1589 1590static inline int security_inode_alloc (struct inode *inode) 1591{ 1592 inode->i_security = NULL; 1593 return security_ops->inode_alloc_security (inode); 1594} 1595 1596static inline void security_inode_free (struct inode *inode) 1597{ 1598 security_ops->inode_free_security (inode); 1599} 1600 1601static inline int security_inode_init_security (struct inode *inode, 1602 struct inode *dir, 1603 char **name, 1604 void **value, 1605 size_t *len) 1606{ 1607 if (unlikely (IS_PRIVATE (inode))) 1608 return -EOPNOTSUPP; 1609 return security_ops->inode_init_security (inode, dir, name, value, len); 1610} 1611 1612static inline int security_inode_create (struct inode *dir, 1613 struct dentry *dentry, 1614 int mode) 1615{ 1616 if (unlikely (IS_PRIVATE (dir))) 1617 return 0; 1618 return security_ops->inode_create (dir, dentry, mode); 1619} 1620 1621static inline int security_inode_link (struct dentry *old_dentry, 1622 struct inode *dir, 1623 struct dentry *new_dentry) 1624{ 1625 if (unlikely (IS_PRIVATE (old_dentry->d_inode))) 1626 return 0; 1627 return security_ops->inode_link (old_dentry, dir, new_dentry); 1628} 1629 1630static inline int security_inode_unlink (struct inode *dir, 1631 struct dentry *dentry) 1632{ 1633 if (unlikely (IS_PRIVATE (dentry->d_inode))) 1634 return 0; 1635 return security_ops->inode_unlink (dir, dentry); 1636} 1637 1638static inline int security_inode_symlink (struct inode *dir, 1639 struct dentry *dentry, 1640 const char *old_name) 1641{ 1642 if (unlikely (IS_PRIVATE (dir))) 1643 return 0; 1644 return security_ops->inode_symlink (dir, dentry, old_name); 1645} 1646 1647static inline int security_inode_mkdir (struct inode *dir, 1648 struct dentry *dentry, 1649 int mode) 1650{ 1651 if (unlikely (IS_PRIVATE (dir))) 1652 return 0; 1653 return security_ops->inode_mkdir (dir, dentry, mode); 1654} 1655 1656static inline int security_inode_rmdir (struct inode *dir, 1657 struct dentry *dentry) 1658{ 1659 if (unlikely (IS_PRIVATE (dentry->d_inode))) 1660 return 0; 1661 return security_ops->inode_rmdir (dir, dentry); 1662} 1663 1664static inline int security_inode_mknod (struct inode *dir, 1665 struct dentry *dentry, 1666 int mode, dev_t dev) 1667{ 1668 if (unlikely (IS_PRIVATE (dir))) 1669 return 0; 1670 return security_ops->inode_mknod (dir, dentry, mode, dev); 1671} 1672 1673static inline int security_inode_rename (struct inode *old_dir, 1674 struct dentry *old_dentry, 1675 struct inode *new_dir, 1676 struct dentry *new_dentry) 1677{ 1678 if (unlikely (IS_PRIVATE (old_dentry->d_inode) || 1679 (new_dentry->d_inode && IS_PRIVATE (new_dentry->d_inode)))) 1680 return 0; 1681 return security_ops->inode_rename (old_dir, old_dentry, 1682 new_dir, new_dentry); 1683} 1684 1685static inline int security_inode_readlink (struct dentry *dentry) 1686{ 1687 if (unlikely (IS_PRIVATE (dentry->d_inode))) 1688 return 0; 1689 return security_ops->inode_readlink (dentry); 1690} 1691 1692static inline int security_inode_follow_link (struct dentry *dentry, 1693 struct nameidata *nd) 1694{ 1695 if (unlikely (IS_PRIVATE (dentry->d_inode))) 1696 return 0; 1697 return security_ops->inode_follow_link (dentry, nd); 1698} 1699 1700static inline int security_inode_permission (struct inode *inode, int mask, 1701 struct nameidata *nd) 1702{ 1703 if (unlikely (IS_PRIVATE (inode))) 1704 return 0; 1705 return security_ops->inode_permission (inode, mask, nd); 1706} 1707 1708static inline int security_inode_setattr (struct dentry *dentry, 1709 struct iattr *attr) 1710{ 1711 if (unlikely (IS_PRIVATE (dentry->d_inode))) 1712 return 0; 1713 return security_ops->inode_setattr (dentry, attr); 1714} 1715 1716static inline int security_inode_getattr (struct vfsmount *mnt, 1717 struct dentry *dentry) 1718{ 1719 if (unlikely (IS_PRIVATE (dentry->d_inode))) 1720 return 0; 1721 return security_ops->inode_getattr (mnt, dentry); 1722} 1723 1724static inline void security_inode_delete (struct inode *inode) 1725{ 1726 if (unlikely (IS_PRIVATE (inode))) 1727 return; 1728 security_ops->inode_delete (inode); 1729} 1730 1731static inline int security_inode_setxattr (struct dentry *dentry, char *name, 1732 void *value, size_t size, int flags) 1733{ 1734 if (unlikely (IS_PRIVATE (dentry->d_inode))) 1735 return 0; 1736 return security_ops->inode_setxattr (dentry, name, value, size, flags); 1737} 1738 1739static inline void security_inode_post_setxattr (struct dentry *dentry, char *name, 1740 void *value, size_t size, int flags) 1741{ 1742 if (unlikely (IS_PRIVATE (dentry->d_inode))) 1743 return; 1744 security_ops->inode_post_setxattr (dentry, name, value, size, flags); 1745} 1746 1747static inline int security_inode_getxattr (struct dentry *dentry, char *name) 1748{ 1749 if (unlikely (IS_PRIVATE (dentry->d_inode))) 1750 return 0; 1751 return security_ops->inode_getxattr (dentry, name); 1752} 1753 1754static inline int security_inode_listxattr (struct dentry *dentry) 1755{ 1756 if (unlikely (IS_PRIVATE (dentry->d_inode))) 1757 return 0; 1758 return security_ops->inode_listxattr (dentry); 1759} 1760 1761static inline int security_inode_removexattr (struct dentry *dentry, char *name) 1762{ 1763 if (unlikely (IS_PRIVATE (dentry->d_inode))) 1764 return 0; 1765 return security_ops->inode_removexattr (dentry, name); 1766} 1767 1768static inline const char *security_inode_xattr_getsuffix(void) 1769{ 1770 return security_ops->inode_xattr_getsuffix(); 1771} 1772 1773static inline int security_inode_getsecurity(const struct inode *inode, const char *name, void *buffer, size_t size, int err) 1774{ 1775 if (unlikely (IS_PRIVATE (inode))) 1776 return 0; 1777 return security_ops->inode_getsecurity(inode, name, buffer, size, err); 1778} 1779 1780static inline int security_inode_setsecurity(struct inode *inode, const char *name, const void *value, size_t size, int flags) 1781{ 1782 if (unlikely (IS_PRIVATE (inode))) 1783 return 0; 1784 return security_ops->inode_setsecurity(inode, name, value, size, flags); 1785} 1786 1787static inline int security_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size) 1788{ 1789 if (unlikely (IS_PRIVATE (inode))) 1790 return 0; 1791 return security_ops->inode_listsecurity(inode, buffer, buffer_size); 1792} 1793 1794static inline int security_file_permission (struct file *file, int mask) 1795{ 1796 return security_ops->file_permission (file, mask); 1797} 1798 1799static inline int security_file_alloc (struct file *file) 1800{ 1801 return security_ops->file_alloc_security (file); 1802} 1803 1804static inline void security_file_free (struct file *file) 1805{ 1806 security_ops->file_free_security (file); 1807} 1808 1809static inline int security_file_ioctl (struct file *file, unsigned int cmd, 1810 unsigned long arg) 1811{ 1812 return security_ops->file_ioctl (file, cmd, arg); 1813} 1814 1815static inline int security_file_mmap (struct file *file, unsigned long reqprot, 1816 unsigned long prot, 1817 unsigned long flags) 1818{ 1819 return security_ops->file_mmap (file, reqprot, prot, flags); 1820} 1821 1822static inline int security_file_mprotect (struct vm_area_struct *vma, 1823 unsigned long reqprot, 1824 unsigned long prot) 1825{ 1826 return security_ops->file_mprotect (vma, reqprot, prot); 1827} 1828 1829static inline int security_file_lock (struct file *file, unsigned int cmd) 1830{ 1831 return security_ops->file_lock (file, cmd); 1832} 1833 1834static inline int security_file_fcntl (struct file *file, unsigned int cmd, 1835 unsigned long arg) 1836{ 1837 return security_ops->file_fcntl (file, cmd, arg); 1838} 1839 1840static inline int security_file_set_fowner (struct file *file) 1841{ 1842 return security_ops->file_set_fowner (file); 1843} 1844 1845static inline int security_file_send_sigiotask (struct task_struct *tsk, 1846 struct fown_struct *fown, 1847 int sig) 1848{ 1849 return security_ops->file_send_sigiotask (tsk, fown, sig); 1850} 1851 1852static inline int security_file_receive (struct file *file) 1853{ 1854 return security_ops->file_receive (file); 1855} 1856 1857static inline int security_task_create (unsigned long clone_flags) 1858{ 1859 return security_ops->task_create (clone_flags); 1860} 1861 1862static inline int security_task_alloc (struct task_struct *p) 1863{ 1864 return security_ops->task_alloc_security (p); 1865} 1866 1867static inline void security_task_free (struct task_struct *p) 1868{ 1869 security_ops->task_free_security (p); 1870} 1871 1872static inline int security_task_setuid (uid_t id0, uid_t id1, uid_t id2, 1873 int flags) 1874{ 1875 return security_ops->task_setuid (id0, id1, id2, flags); 1876} 1877 1878static inline int security_task_post_setuid (uid_t old_ruid, uid_t old_euid, 1879 uid_t old_suid, int flags) 1880{ 1881 return security_ops->task_post_setuid (old_ruid, old_euid, old_suid, flags); 1882} 1883 1884static inline int security_task_setgid (gid_t id0, gid_t id1, gid_t id2, 1885 int flags) 1886{ 1887 return security_ops->task_setgid (id0, id1, id2, flags); 1888} 1889 1890static inline int security_task_setpgid (struct task_struct *p, pid_t pgid) 1891{ 1892 return security_ops->task_setpgid (p, pgid); 1893} 1894 1895static inline int security_task_getpgid (struct task_struct *p) 1896{ 1897 return security_ops->task_getpgid (p); 1898} 1899 1900static inline int security_task_getsid (struct task_struct *p) 1901{ 1902 return security_ops->task_getsid (p); 1903} 1904 1905static inline void security_task_getsecid (struct task_struct *p, u32 *secid) 1906{ 1907 security_ops->task_getsecid (p, secid); 1908} 1909 1910static inline int security_task_setgroups (struct group_info *group_info) 1911{ 1912 return security_ops->task_setgroups (group_info); 1913} 1914 1915static inline int security_task_setnice (struct task_struct *p, int nice) 1916{ 1917 return security_ops->task_setnice (p, nice); 1918} 1919 1920static inline int security_task_setioprio (struct task_struct *p, int ioprio) 1921{ 1922 return security_ops->task_setioprio (p, ioprio); 1923} 1924 1925static inline int security_task_getioprio (struct task_struct *p) 1926{ 1927 return security_ops->task_getioprio (p); 1928} 1929 1930static inline int security_task_setrlimit (unsigned int resource, 1931 struct rlimit *new_rlim) 1932{ 1933 return security_ops->task_setrlimit (resource, new_rlim); 1934} 1935 1936static inline int security_task_setscheduler (struct task_struct *p, 1937 int policy, 1938 struct sched_param *lp) 1939{ 1940 return security_ops->task_setscheduler (p, policy, lp); 1941} 1942 1943static inline int security_task_getscheduler (struct task_struct *p) 1944{ 1945 return security_ops->task_getscheduler (p); 1946} 1947 1948static inline int security_task_movememory (struct task_struct *p) 1949{ 1950 return security_ops->task_movememory (p); 1951} 1952 1953static inline int security_task_kill (struct task_struct *p, 1954 struct siginfo *info, int sig, 1955 u32 secid) 1956{ 1957 return security_ops->task_kill (p, info, sig, secid); 1958} 1959 1960static inline int security_task_wait (struct task_struct *p) 1961{ 1962 return security_ops->task_wait (p); 1963} 1964 1965static inline int security_task_prctl (int option, unsigned long arg2, 1966 unsigned long arg3, 1967 unsigned long arg4, 1968 unsigned long arg5) 1969{ 1970 return security_ops->task_prctl (option, arg2, arg3, arg4, arg5); 1971} 1972 1973static inline void security_task_reparent_to_init (struct task_struct *p) 1974{ 1975 security_ops->task_reparent_to_init (p); 1976} 1977 1978static inline void security_task_to_inode(struct task_struct *p, struct inode *inode) 1979{ 1980 security_ops->task_to_inode(p, inode); 1981} 1982 1983static inline int security_ipc_permission (struct kern_ipc_perm *ipcp, 1984 short flag) 1985{ 1986 return security_ops->ipc_permission (ipcp, flag); 1987} 1988 1989static inline int security_msg_msg_alloc (struct msg_msg * msg) 1990{ 1991 return security_ops->msg_msg_alloc_security (msg); 1992} 1993 1994static inline void security_msg_msg_free (struct msg_msg * msg) 1995{ 1996 security_ops->msg_msg_free_security(msg); 1997} 1998 1999static inline int security_msg_queue_alloc (struct msg_queue *msq) 2000{ 2001 return security_ops->msg_queue_alloc_security (msq); 2002} 2003 2004static inline void security_msg_queue_free (struct msg_queue *msq) 2005{ 2006 security_ops->msg_queue_free_security (msq); 2007} 2008 2009static inline int security_msg_queue_associate (struct msg_queue * msq, 2010 int msqflg) 2011{ 2012 return security_ops->msg_queue_associate (msq, msqflg); 2013} 2014 2015static inline int security_msg_queue_msgctl (struct msg_queue * msq, int cmd) 2016{ 2017 return security_ops->msg_queue_msgctl (msq, cmd); 2018} 2019 2020static inline int security_msg_queue_msgsnd (struct msg_queue * msq, 2021 struct msg_msg * msg, int msqflg) 2022{ 2023 return security_ops->msg_queue_msgsnd (msq, msg, msqflg); 2024} 2025 2026static inline int security_msg_queue_msgrcv (struct msg_queue * msq, 2027 struct msg_msg * msg, 2028 struct task_struct * target, 2029 long type, int mode) 2030{ 2031 return security_ops->msg_queue_msgrcv (msq, msg, target, type, mode); 2032} 2033 2034static inline int security_shm_alloc (struct shmid_kernel *shp) 2035{ 2036 return security_ops->shm_alloc_security (shp); 2037} 2038 2039static inline void security_shm_free (struct shmid_kernel *shp) 2040{ 2041 security_ops->shm_free_security (shp); 2042} 2043 2044static inline int security_shm_associate (struct shmid_kernel * shp, 2045 int shmflg) 2046{ 2047 return security_ops->shm_associate(shp, shmflg); 2048} 2049 2050static inline int security_shm_shmctl (struct shmid_kernel * shp, int cmd) 2051{ 2052 return security_ops->shm_shmctl (shp, cmd); 2053} 2054 2055static inline int security_shm_shmat (struct shmid_kernel * shp, 2056 char __user *shmaddr, int shmflg) 2057{ 2058 return security_ops->shm_shmat(shp, shmaddr, shmflg); 2059} 2060 2061static inline int security_sem_alloc (struct sem_array *sma) 2062{ 2063 return security_ops->sem_alloc_security (sma); 2064} 2065 2066static inline void security_sem_free (struct sem_array *sma) 2067{ 2068 security_ops->sem_free_security (sma); 2069} 2070 2071static inline int security_sem_associate (struct sem_array * sma, int semflg) 2072{ 2073 return security_ops->sem_associate (sma, semflg); 2074} 2075 2076static inline int security_sem_semctl (struct sem_array * sma, int cmd) 2077{ 2078 return security_ops->sem_semctl(sma, cmd); 2079} 2080 2081static inline int security_sem_semop (struct sem_array * sma, 2082 struct sembuf * sops, unsigned nsops, 2083 int alter) 2084{ 2085 return security_ops->sem_semop(sma, sops, nsops, alter); 2086} 2087 2088static inline void security_d_instantiate (struct dentry *dentry, struct inode *inode) 2089{ 2090 if (unlikely (inode && IS_PRIVATE (inode))) 2091 return; 2092 security_ops->d_instantiate (dentry, inode); 2093} 2094 2095static inline int security_getprocattr(struct task_struct *p, char *name, char **value) 2096{ 2097 return security_ops->getprocattr(p, name, value); 2098} 2099 2100static inline int security_setprocattr(struct task_struct *p, char *name, void *value, size_t size) 2101{ 2102 return security_ops->setprocattr(p, name, value, size); 2103} 2104 2105static inline int security_netlink_send(struct sock *sk, struct sk_buff * skb) 2106{ 2107 return security_ops->netlink_send(sk, skb); 2108} 2109 2110static inline int security_netlink_recv(struct sk_buff * skb, int cap) 2111{ 2112 return security_ops->netlink_recv(skb, cap); 2113} 2114 2115static inline int security_secid_to_secctx(u32 secid, char **secdata, u32 *seclen) 2116{ 2117 return security_ops->secid_to_secctx(secid, secdata, seclen); 2118} 2119 2120static inline void security_release_secctx(char *secdata, u32 seclen) 2121{ 2122 return security_ops->release_secctx(secdata, seclen); 2123} 2124 2125/* prototypes */ 2126extern int security_init (void); 2127extern int register_security (struct security_operations *ops); 2128extern int unregister_security (struct security_operations *ops); 2129extern int mod_reg_security (const char *name, struct security_operations *ops); 2130extern int mod_unreg_security (const char *name, struct security_operations *ops); 2131extern struct dentry *securityfs_create_file(const char *name, mode_t mode, 2132 struct dentry *parent, void *data, 2133 const struct file_operations *fops); 2134extern struct dentry *securityfs_create_dir(const char *name, struct dentry *parent); 2135extern void securityfs_remove(struct dentry *dentry); 2136 2137 2138#else /* CONFIG_SECURITY */ 2139 2140/* 2141 * This is the default capabilities functionality. Most of these functions 2142 * are just stubbed out, but a few must call the proper capable code. 2143 */ 2144 2145static inline int security_init(void) 2146{ 2147 return 0; 2148} 2149 2150static inline int security_ptrace (struct task_struct *parent, struct task_struct * child) 2151{ 2152 return cap_ptrace (parent, child); 2153} 2154 2155static inline int security_capget (struct task_struct *target, 2156 kernel_cap_t *effective, 2157 kernel_cap_t *inheritable, 2158 kernel_cap_t *permitted) 2159{ 2160 return cap_capget (target, effective, inheritable, permitted); 2161} 2162 2163static inline int security_capset_check (struct task_struct *target, 2164 kernel_cap_t *effective, 2165 kernel_cap_t *inheritable, 2166 kernel_cap_t *permitted) 2167{ 2168 return cap_capset_check (target, effective, inheritable, permitted); 2169} 2170 2171static inline void security_capset_set (struct task_struct *target, 2172 kernel_cap_t *effective, 2173 kernel_cap_t *inheritable, 2174 kernel_cap_t *permitted) 2175{ 2176 cap_capset_set (target, effective, inheritable, permitted); 2177} 2178 2179static inline int security_capable(struct task_struct *tsk, int cap) 2180{ 2181 return cap_capable(tsk, cap); 2182} 2183 2184static inline int security_acct (struct file *file) 2185{ 2186 return 0; 2187} 2188 2189static inline int security_sysctl(struct ctl_table *table, int op) 2190{ 2191 return 0; 2192} 2193 2194static inline int security_quotactl (int cmds, int type, int id, 2195 struct super_block * sb) 2196{ 2197 return 0; 2198} 2199 2200static inline int security_quota_on (struct dentry * dentry) 2201{ 2202 return 0; 2203} 2204 2205static inline int security_syslog(int type) 2206{ 2207 return cap_syslog(type); 2208} 2209 2210static inline int security_settime(struct timespec *ts, struct timezone *tz) 2211{ 2212 return cap_settime(ts, tz); 2213} 2214 2215static inline int security_vm_enough_memory(long pages) 2216{ 2217 return cap_vm_enough_memory(pages); 2218} 2219 2220static inline int security_bprm_alloc (struct linux_binprm *bprm) 2221{ 2222 return 0; 2223} 2224 2225static inline void security_bprm_free (struct linux_binprm *bprm) 2226{ } 2227 2228static inline void security_bprm_apply_creds (struct linux_binprm *bprm, int unsafe) 2229{ 2230 cap_bprm_apply_creds (bprm, unsafe); 2231} 2232 2233static inline void security_bprm_post_apply_creds (struct linux_binprm *bprm) 2234{ 2235 return; 2236} 2237 2238static inline int security_bprm_set (struct linux_binprm *bprm) 2239{ 2240 return cap_bprm_set_security (bprm); 2241} 2242 2243static inline int security_bprm_check (struct linux_binprm *bprm) 2244{ 2245 return 0; 2246} 2247 2248static inline int security_bprm_secureexec (struct linux_binprm *bprm) 2249{ 2250 return cap_bprm_secureexec(bprm); 2251} 2252 2253static inline int security_sb_alloc (struct super_block *sb) 2254{ 2255 return 0; 2256} 2257 2258static inline void security_sb_free (struct super_block *sb) 2259{ } 2260 2261static inline int security_sb_copy_data (struct file_system_type *type, 2262 void *orig, void *copy) 2263{ 2264 return 0; 2265} 2266 2267static inline int security_sb_kern_mount (struct super_block *sb, void *data) 2268{ 2269 return 0; 2270} 2271 2272static inline int security_sb_statfs (struct dentry *dentry) 2273{ 2274 return 0; 2275} 2276 2277static inline int security_sb_mount (char *dev_name, struct nameidata *nd, 2278 char *type, unsigned long flags, 2279 void *data) 2280{ 2281 return 0; 2282} 2283 2284static inline int security_sb_check_sb (struct vfsmount *mnt, 2285 struct nameidata *nd) 2286{ 2287 return 0; 2288} 2289 2290static inline int security_sb_umount (struct vfsmount *mnt, int flags) 2291{ 2292 return 0; 2293} 2294 2295static inline void security_sb_umount_close (struct vfsmount *mnt) 2296{ } 2297 2298static inline void security_sb_umount_busy (struct vfsmount *mnt) 2299{ } 2300 2301static inline void security_sb_post_remount (struct vfsmount *mnt, 2302 unsigned long flags, void *data) 2303{ } 2304 2305static inline void security_sb_post_mountroot (void) 2306{ } 2307 2308static inline void security_sb_post_addmount (struct vfsmount *mnt, 2309 struct nameidata *mountpoint_nd) 2310{ } 2311 2312static inline int security_sb_pivotroot (struct nameidata *old_nd, 2313 struct nameidata *new_nd) 2314{ 2315 return 0; 2316} 2317 2318static inline void security_sb_post_pivotroot (struct nameidata *old_nd, 2319 struct nameidata *new_nd) 2320{ } 2321 2322static inline int security_inode_alloc (struct inode *inode) 2323{ 2324 return 0; 2325} 2326 2327static inline void security_inode_free (struct inode *inode) 2328{ } 2329 2330static inline int security_inode_init_security (struct inode *inode, 2331 struct inode *dir, 2332 char **name, 2333 void **value, 2334 size_t *len) 2335{ 2336 return -EOPNOTSUPP; 2337} 2338 2339static inline int security_inode_create (struct inode *dir, 2340 struct dentry *dentry, 2341 int mode) 2342{ 2343 return 0; 2344} 2345 2346static inline int security_inode_link (struct dentry *old_dentry, 2347 struct inode *dir, 2348 struct dentry *new_dentry) 2349{ 2350 return 0; 2351} 2352 2353static inline int security_inode_unlink (struct inode *dir, 2354 struct dentry *dentry) 2355{ 2356 return 0; 2357} 2358 2359static inline int security_inode_symlink (struct inode *dir, 2360 struct dentry *dentry, 2361 const char *old_name) 2362{ 2363 return 0; 2364} 2365 2366static inline int security_inode_mkdir (struct inode *dir, 2367 struct dentry *dentry, 2368 int mode) 2369{ 2370 return 0; 2371} 2372 2373static inline int security_inode_rmdir (struct inode *dir, 2374 struct dentry *dentry) 2375{ 2376 return 0; 2377} 2378 2379static inline int security_inode_mknod (struct inode *dir, 2380 struct dentry *dentry, 2381 int mode, dev_t dev) 2382{ 2383 return 0; 2384} 2385 2386static inline int security_inode_rename (struct inode *old_dir, 2387 struct dentry *old_dentry, 2388 struct inode *new_dir, 2389 struct dentry *new_dentry) 2390{ 2391 return 0; 2392} 2393 2394static inline int security_inode_readlink (struct dentry *dentry) 2395{ 2396 return 0; 2397} 2398 2399static inline int security_inode_follow_link (struct dentry *dentry, 2400 struct nameidata *nd) 2401{ 2402 return 0; 2403} 2404 2405static inline int security_inode_permission (struct inode *inode, int mask, 2406 struct nameidata *nd) 2407{ 2408 return 0; 2409} 2410 2411static inline int security_inode_setattr (struct dentry *dentry, 2412 struct iattr *attr) 2413{ 2414 return 0; 2415} 2416 2417static inline int security_inode_getattr (struct vfsmount *mnt, 2418 struct dentry *dentry) 2419{ 2420 return 0; 2421} 2422 2423static inline void security_inode_delete (struct inode *inode) 2424{ } 2425 2426static inline int security_inode_setxattr (struct dentry *dentry, char *name, 2427 void *value, size_t size, int flags) 2428{ 2429 return cap_inode_setxattr(dentry, name, value, size, flags); 2430} 2431 2432static inline void security_inode_post_setxattr (struct dentry *dentry, char *name, 2433 void *value, size_t size, int flags) 2434{ } 2435 2436static inline int security_inode_getxattr (struct dentry *dentry, char *name) 2437{ 2438 return 0; 2439} 2440 2441static inline int security_inode_listxattr (struct dentry *dentry) 2442{ 2443 return 0; 2444} 2445 2446static inline int security_inode_removexattr (struct dentry *dentry, char *name) 2447{ 2448 return cap_inode_removexattr(dentry, name); 2449} 2450 2451static inline const char *security_inode_xattr_getsuffix (void) 2452{ 2453 return NULL ; 2454} 2455 2456static inline int security_inode_getsecurity(const struct inode *inode, const char *name, void *buffer, size_t size, int err) 2457{ 2458 return -EOPNOTSUPP; 2459} 2460 2461static inline int security_inode_setsecurity(struct inode *inode, const char *name, const void *value, size_t size, int flags) 2462{ 2463 return -EOPNOTSUPP; 2464} 2465 2466static inline int security_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size) 2467{ 2468 return 0; 2469} 2470 2471static inline int security_file_permission (struct file *file, int mask) 2472{ 2473 return 0; 2474} 2475 2476static inline int security_file_alloc (struct file *file) 2477{ 2478 return 0; 2479} 2480 2481static inline void security_file_free (struct file *file) 2482{ } 2483 2484static inline int security_file_ioctl (struct file *file, unsigned int cmd, 2485 unsigned long arg) 2486{ 2487 return 0; 2488} 2489 2490static inline int security_file_mmap (struct file *file, unsigned long reqprot, 2491 unsigned long prot, 2492 unsigned long flags) 2493{ 2494 return 0; 2495} 2496 2497static inline int security_file_mprotect (struct vm_area_struct *vma, 2498 unsigned long reqprot, 2499 unsigned long prot) 2500{ 2501 return 0; 2502} 2503 2504static inline int security_file_lock (struct file *file, unsigned int cmd) 2505{ 2506 return 0; 2507} 2508 2509static inline int security_file_fcntl (struct file *file, unsigned int cmd, 2510 unsigned long arg) 2511{ 2512 return 0; 2513} 2514 2515static inline int security_file_set_fowner (struct file *file) 2516{ 2517 return 0; 2518} 2519 2520static inline int security_file_send_sigiotask (struct task_struct *tsk, 2521 struct fown_struct *fown, 2522 int sig) 2523{ 2524 return 0; 2525} 2526 2527static inline int security_file_receive (struct file *file) 2528{ 2529 return 0; 2530} 2531 2532static inline int security_task_create (unsigned long clone_flags) 2533{ 2534 return 0; 2535} 2536 2537static inline int security_task_alloc (struct task_struct *p) 2538{ 2539 return 0; 2540} 2541 2542static inline void security_task_free (struct task_struct *p) 2543{ } 2544 2545static inline int security_task_setuid (uid_t id0, uid_t id1, uid_t id2, 2546 int flags) 2547{ 2548 return 0; 2549} 2550 2551static inline int security_task_post_setuid (uid_t old_ruid, uid_t old_euid, 2552 uid_t old_suid, int flags) 2553{ 2554 return cap_task_post_setuid (old_ruid, old_euid, old_suid, flags); 2555} 2556 2557static inline int security_task_setgid (gid_t id0, gid_t id1, gid_t id2, 2558 int flags) 2559{ 2560 return 0; 2561} 2562 2563static inline int security_task_setpgid (struct task_struct *p, pid_t pgid) 2564{ 2565 return 0; 2566} 2567 2568static inline int security_task_getpgid (struct task_struct *p) 2569{ 2570 return 0; 2571} 2572 2573static inline int security_task_getsid (struct task_struct *p) 2574{ 2575 return 0; 2576} 2577 2578static inline void security_task_getsecid (struct task_struct *p, u32 *secid) 2579{ } 2580 2581static inline int security_task_setgroups (struct group_info *group_info) 2582{ 2583 return 0; 2584} 2585 2586static inline int security_task_setnice (struct task_struct *p, int nice) 2587{ 2588 return 0; 2589} 2590 2591static inline int security_task_setioprio (struct task_struct *p, int ioprio) 2592{ 2593 return 0; 2594} 2595 2596static inline int security_task_getioprio (struct task_struct *p) 2597{ 2598 return 0; 2599} 2600 2601static inline int security_task_setrlimit (unsigned int resource, 2602 struct rlimit *new_rlim) 2603{ 2604 return 0; 2605} 2606 2607static inline int security_task_setscheduler (struct task_struct *p, 2608 int policy, 2609 struct sched_param *lp) 2610{ 2611 return 0; 2612} 2613 2614static inline int security_task_getscheduler (struct task_struct *p) 2615{ 2616 return 0; 2617} 2618 2619static inline int security_task_movememory (struct task_struct *p) 2620{ 2621 return 0; 2622} 2623 2624static inline int security_task_kill (struct task_struct *p, 2625 struct siginfo *info, int sig, 2626 u32 secid) 2627{ 2628 return 0; 2629} 2630 2631static inline int security_task_wait (struct task_struct *p) 2632{ 2633 return 0; 2634} 2635 2636static inline int security_task_prctl (int option, unsigned long arg2, 2637 unsigned long arg3, 2638 unsigned long arg4, 2639 unsigned long arg5) 2640{ 2641 return 0; 2642} 2643 2644static inline void security_task_reparent_to_init (struct task_struct *p) 2645{ 2646 cap_task_reparent_to_init (p); 2647} 2648 2649static inline void security_task_to_inode(struct task_struct *p, struct inode *inode) 2650{ } 2651 2652static inline int security_ipc_permission (struct kern_ipc_perm *ipcp, 2653 short flag) 2654{ 2655 return 0; 2656} 2657 2658static inline int security_msg_msg_alloc (struct msg_msg * msg) 2659{ 2660 return 0; 2661} 2662 2663static inline void security_msg_msg_free (struct msg_msg * msg) 2664{ } 2665 2666static inline int security_msg_queue_alloc (struct msg_queue *msq) 2667{ 2668 return 0; 2669} 2670 2671static inline void security_msg_queue_free (struct msg_queue *msq) 2672{ } 2673 2674static inline int security_msg_queue_associate (struct msg_queue * msq, 2675 int msqflg) 2676{ 2677 return 0; 2678} 2679 2680static inline int security_msg_queue_msgctl (struct msg_queue * msq, int cmd) 2681{ 2682 return 0; 2683} 2684 2685static inline int security_msg_queue_msgsnd (struct msg_queue * msq, 2686 struct msg_msg * msg, int msqflg) 2687{ 2688 return 0; 2689} 2690 2691static inline int security_msg_queue_msgrcv (struct msg_queue * msq, 2692 struct msg_msg * msg, 2693 struct task_struct * target, 2694 long type, int mode) 2695{ 2696 return 0; 2697} 2698 2699static inline int security_shm_alloc (struct shmid_kernel *shp) 2700{ 2701 return 0; 2702} 2703 2704static inline void security_shm_free (struct shmid_kernel *shp) 2705{ } 2706 2707static inline int security_shm_associate (struct shmid_kernel * shp, 2708 int shmflg) 2709{ 2710 return 0; 2711} 2712 2713static inline int security_shm_shmctl (struct shmid_kernel * shp, int cmd) 2714{ 2715 return 0; 2716} 2717 2718static inline int security_shm_shmat (struct shmid_kernel * shp, 2719 char __user *shmaddr, int shmflg) 2720{ 2721 return 0; 2722} 2723 2724static inline int security_sem_alloc (struct sem_array *sma) 2725{ 2726 return 0; 2727} 2728 2729static inline void security_sem_free (struct sem_array *sma) 2730{ } 2731 2732static inline int security_sem_associate (struct sem_array * sma, int semflg) 2733{ 2734 return 0; 2735} 2736 2737static inline int security_sem_semctl (struct sem_array * sma, int cmd) 2738{ 2739 return 0; 2740} 2741 2742static inline int security_sem_semop (struct sem_array * sma, 2743 struct sembuf * sops, unsigned nsops, 2744 int alter) 2745{ 2746 return 0; 2747} 2748 2749static inline void security_d_instantiate (struct dentry *dentry, struct inode *inode) 2750{ } 2751 2752static inline int security_getprocattr(struct task_struct *p, char *name, char **value) 2753{ 2754 return -EINVAL; 2755} 2756 2757static inline int security_setprocattr(struct task_struct *p, char *name, void *value, size_t size) 2758{ 2759 return -EINVAL; 2760} 2761 2762static inline int security_netlink_send (struct sock *sk, struct sk_buff *skb) 2763{ 2764 return cap_netlink_send (sk, skb); 2765} 2766 2767static inline int security_netlink_recv (struct sk_buff *skb, int cap) 2768{ 2769 return cap_netlink_recv (skb, cap); 2770} 2771 2772static inline struct dentry *securityfs_create_dir(const char *name, 2773 struct dentry *parent) 2774{ 2775 return ERR_PTR(-ENODEV); 2776} 2777 2778static inline struct dentry *securityfs_create_file(const char *name, 2779 mode_t mode, 2780 struct dentry *parent, 2781 void *data, 2782 struct file_operations *fops) 2783{ 2784 return ERR_PTR(-ENODEV); 2785} 2786 2787static inline void securityfs_remove(struct dentry *dentry) 2788{ 2789} 2790 2791static inline int security_secid_to_secctx(u32 secid, char **secdata, u32 *seclen) 2792{ 2793 return -EOPNOTSUPP; 2794} 2795 2796static inline void security_release_secctx(char *secdata, u32 seclen) 2797{ 2798} 2799#endif /* CONFIG_SECURITY */ 2800 2801#ifdef CONFIG_SECURITY_NETWORK 2802static inline int security_unix_stream_connect(struct socket * sock, 2803 struct socket * other, 2804 struct sock * newsk) 2805{ 2806 return security_ops->unix_stream_connect(sock, other, newsk); 2807} 2808 2809 2810static inline int security_unix_may_send(struct socket * sock, 2811 struct socket * other) 2812{ 2813 return security_ops->unix_may_send(sock, other); 2814} 2815 2816static inline int security_socket_create (int family, int type, 2817 int protocol, int kern) 2818{ 2819 return security_ops->socket_create(family, type, protocol, kern); 2820} 2821 2822static inline int security_socket_post_create(struct socket * sock, 2823 int family, 2824 int type, 2825 int protocol, int kern) 2826{ 2827 return security_ops->socket_post_create(sock, family, type, 2828 protocol, kern); 2829} 2830 2831static inline int security_socket_bind(struct socket * sock, 2832 struct sockaddr * address, 2833 int addrlen) 2834{ 2835 return security_ops->socket_bind(sock, address, addrlen); 2836} 2837 2838static inline int security_socket_connect(struct socket * sock, 2839 struct sockaddr * address, 2840 int addrlen) 2841{ 2842 return security_ops->socket_connect(sock, address, addrlen); 2843} 2844 2845static inline int security_socket_listen(struct socket * sock, int backlog) 2846{ 2847 return security_ops->socket_listen(sock, backlog); 2848} 2849 2850static inline int security_socket_accept(struct socket * sock, 2851 struct socket * newsock) 2852{ 2853 return security_ops->socket_accept(sock, newsock); 2854} 2855 2856static inline void security_socket_post_accept(struct socket * sock, 2857 struct socket * newsock) 2858{ 2859 security_ops->socket_post_accept(sock, newsock); 2860} 2861 2862static inline int security_socket_sendmsg(struct socket * sock, 2863 struct msghdr * msg, int size) 2864{ 2865 return security_ops->socket_sendmsg(sock, msg, size); 2866} 2867 2868static inline int security_socket_recvmsg(struct socket * sock, 2869 struct msghdr * msg, int size, 2870 int flags) 2871{ 2872 return security_ops->socket_recvmsg(sock, msg, size, flags); 2873} 2874 2875static inline int security_socket_getsockname(struct socket * sock) 2876{ 2877 return security_ops->socket_getsockname(sock); 2878} 2879 2880static inline int security_socket_getpeername(struct socket * sock) 2881{ 2882 return security_ops->socket_getpeername(sock); 2883} 2884 2885static inline int security_socket_getsockopt(struct socket * sock, 2886 int level, int optname) 2887{ 2888 return security_ops->socket_getsockopt(sock, level, optname); 2889} 2890 2891static inline int security_socket_setsockopt(struct socket * sock, 2892 int level, int optname) 2893{ 2894 return security_ops->socket_setsockopt(sock, level, optname); 2895} 2896 2897static inline int security_socket_shutdown(struct socket * sock, int how) 2898{ 2899 return security_ops->socket_shutdown(sock, how); 2900} 2901 2902static inline int security_sock_rcv_skb (struct sock * sk, 2903 struct sk_buff * skb) 2904{ 2905 return security_ops->socket_sock_rcv_skb (sk, skb); 2906} 2907 2908static inline int security_socket_getpeersec_stream(struct socket *sock, char __user *optval, 2909 int __user *optlen, unsigned len) 2910{ 2911 return security_ops->socket_getpeersec_stream(sock, optval, optlen, len); 2912} 2913 2914static inline int security_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid) 2915{ 2916 return security_ops->socket_getpeersec_dgram(sock, skb, secid); 2917} 2918 2919static inline int security_sk_alloc(struct sock *sk, int family, gfp_t priority) 2920{ 2921 return security_ops->sk_alloc_security(sk, family, priority); 2922} 2923 2924static inline void security_sk_free(struct sock *sk) 2925{ 2926 return security_ops->sk_free_security(sk); 2927} 2928 2929static inline void security_sk_clone(const struct sock *sk, struct sock *newsk) 2930{ 2931 return security_ops->sk_clone_security(sk, newsk); 2932} 2933 2934static inline void security_sk_classify_flow(struct sock *sk, struct flowi *fl) 2935{ 2936 security_ops->sk_getsecid(sk, &fl->secid); 2937} 2938 2939static inline void security_req_classify_flow(const struct request_sock *req, struct flowi *fl) 2940{ 2941 security_ops->req_classify_flow(req, fl); 2942} 2943 2944static inline void security_sock_graft(struct sock* sk, struct socket *parent) 2945{ 2946 security_ops->sock_graft(sk, parent); 2947} 2948 2949static inline int security_inet_conn_request(struct sock *sk, 2950 struct sk_buff *skb, struct request_sock *req) 2951{ 2952 return security_ops->inet_conn_request(sk, skb, req); 2953} 2954 2955static inline void security_inet_csk_clone(struct sock *newsk, 2956 const struct request_sock *req) 2957{ 2958 security_ops->inet_csk_clone(newsk, req); 2959} 2960 2961static inline void security_inet_conn_established(struct sock *sk, 2962 struct sk_buff *skb) 2963{ 2964 security_ops->inet_conn_established(sk, skb); 2965} 2966#else /* CONFIG_SECURITY_NETWORK */ 2967static inline int security_unix_stream_connect(struct socket * sock, 2968 struct socket * other, 2969 struct sock * newsk) 2970{ 2971 return 0; 2972} 2973 2974static inline int security_unix_may_send(struct socket * sock, 2975 struct socket * other) 2976{ 2977 return 0; 2978} 2979 2980static inline int security_socket_create (int family, int type, 2981 int protocol, int kern) 2982{ 2983 return 0; 2984} 2985 2986static inline int security_socket_post_create(struct socket * sock, 2987 int family, 2988 int type, 2989 int protocol, int kern) 2990{ 2991 return 0; 2992} 2993 2994static inline int security_socket_bind(struct socket * sock, 2995 struct sockaddr * address, 2996 int addrlen) 2997{ 2998 return 0; 2999} 3000 3001static inline int security_socket_connect(struct socket * sock, 3002 struct sockaddr * address, 3003 int addrlen) 3004{ 3005 return 0; 3006} 3007 3008static inline int security_socket_listen(struct socket * sock, int backlog) 3009{ 3010 return 0; 3011} 3012 3013static inline int security_socket_accept(struct socket * sock, 3014 struct socket * newsock) 3015{ 3016 return 0; 3017} 3018 3019static inline void security_socket_post_accept(struct socket * sock, 3020 struct socket * newsock) 3021{ 3022} 3023 3024static inline int security_socket_sendmsg(struct socket * sock, 3025 struct msghdr * msg, int size) 3026{ 3027 return 0; 3028} 3029 3030static inline int security_socket_recvmsg(struct socket * sock, 3031 struct msghdr * msg, int size, 3032 int flags) 3033{ 3034 return 0; 3035} 3036 3037static inline int security_socket_getsockname(struct socket * sock) 3038{ 3039 return 0; 3040} 3041 3042static inline int security_socket_getpeername(struct socket * sock) 3043{ 3044 return 0; 3045} 3046 3047static inline int security_socket_getsockopt(struct socket * sock, 3048 int level, int optname) 3049{ 3050 return 0; 3051} 3052 3053static inline int security_socket_setsockopt(struct socket * sock, 3054 int level, int optname) 3055{ 3056 return 0; 3057} 3058 3059static inline int security_socket_shutdown(struct socket * sock, int how) 3060{ 3061 return 0; 3062} 3063static inline int security_sock_rcv_skb (struct sock * sk, 3064 struct sk_buff * skb) 3065{ 3066 return 0; 3067} 3068 3069static inline int security_socket_getpeersec_stream(struct socket *sock, char __user *optval, 3070 int __user *optlen, unsigned len) 3071{ 3072 return -ENOPROTOOPT; 3073} 3074 3075static inline int security_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid) 3076{ 3077 return -ENOPROTOOPT; 3078} 3079 3080static inline int security_sk_alloc(struct sock *sk, int family, gfp_t priority) 3081{ 3082 return 0; 3083} 3084 3085static inline void security_sk_free(struct sock *sk) 3086{ 3087} 3088 3089static inline void security_sk_clone(const struct sock *sk, struct sock *newsk) 3090{ 3091} 3092 3093static inline void security_sk_classify_flow(struct sock *sk, struct flowi *fl) 3094{ 3095} 3096 3097static inline void security_req_classify_flow(const struct request_sock *req, struct flowi *fl) 3098{ 3099} 3100 3101static inline void security_sock_graft(struct sock* sk, struct socket *parent) 3102{ 3103} 3104 3105static inline int security_inet_conn_request(struct sock *sk, 3106 struct sk_buff *skb, struct request_sock *req) 3107{ 3108 return 0; 3109} 3110 3111static inline void security_inet_csk_clone(struct sock *newsk, 3112 const struct request_sock *req) 3113{ 3114} 3115 3116static inline void security_inet_conn_established(struct sock *sk, 3117 struct sk_buff *skb) 3118{ 3119} 3120#endif /* CONFIG_SECURITY_NETWORK */ 3121 3122#ifdef CONFIG_SECURITY_NETWORK_XFRM 3123static inline int security_xfrm_policy_alloc(struct xfrm_policy *xp, struct xfrm_user_sec_ctx *sec_ctx) 3124{ 3125 return security_ops->xfrm_policy_alloc_security(xp, sec_ctx); 3126} 3127 3128static inline int security_xfrm_policy_clone(struct xfrm_policy *old, struct xfrm_policy *new) 3129{ 3130 return security_ops->xfrm_policy_clone_security(old, new); 3131} 3132 3133static inline void security_xfrm_policy_free(struct xfrm_policy *xp) 3134{ 3135 security_ops->xfrm_policy_free_security(xp); 3136} 3137 3138static inline int security_xfrm_policy_delete(struct xfrm_policy *xp) 3139{ 3140 return security_ops->xfrm_policy_delete_security(xp); 3141} 3142 3143static inline int security_xfrm_state_alloc(struct xfrm_state *x, 3144 struct xfrm_user_sec_ctx *sec_ctx) 3145{ 3146 return security_ops->xfrm_state_alloc_security(x, sec_ctx, 0); 3147} 3148 3149static inline int security_xfrm_state_alloc_acquire(struct xfrm_state *x, 3150 struct xfrm_sec_ctx *polsec, u32 secid) 3151{ 3152 if (!polsec) 3153 return 0; 3154 /* 3155 * We want the context to be taken from secid which is usually 3156 * from the sock. 3157 */ 3158 return security_ops->xfrm_state_alloc_security(x, NULL, secid); 3159} 3160 3161static inline int security_xfrm_state_delete(struct xfrm_state *x) 3162{ 3163 return security_ops->xfrm_state_delete_security(x); 3164} 3165 3166static inline void security_xfrm_state_free(struct xfrm_state *x) 3167{ 3168 security_ops->xfrm_state_free_security(x); 3169} 3170 3171static inline int security_xfrm_policy_lookup(struct xfrm_policy *xp, u32 fl_secid, u8 dir) 3172{ 3173 return security_ops->xfrm_policy_lookup(xp, fl_secid, dir); 3174} 3175 3176static inline int security_xfrm_state_pol_flow_match(struct xfrm_state *x, 3177 struct xfrm_policy *xp, struct flowi *fl) 3178{ 3179 return security_ops->xfrm_state_pol_flow_match(x, xp, fl); 3180} 3181 3182static inline int security_xfrm_decode_session(struct sk_buff *skb, u32 *secid) 3183{ 3184 return security_ops->xfrm_decode_session(skb, secid, 1); 3185} 3186 3187static inline void security_skb_classify_flow(struct sk_buff *skb, struct flowi *fl) 3188{ 3189 int rc = security_ops->xfrm_decode_session(skb, &fl->secid, 0); 3190 3191 BUG_ON(rc); 3192} 3193#else /* CONFIG_SECURITY_NETWORK_XFRM */ 3194static inline int security_xfrm_policy_alloc(struct xfrm_policy *xp, struct xfrm_user_sec_ctx *sec_ctx) 3195{ 3196 return 0; 3197} 3198 3199static inline int security_xfrm_policy_clone(struct xfrm_policy *old, struct xfrm_policy *new) 3200{ 3201 return 0; 3202} 3203 3204static inline void security_xfrm_policy_free(struct xfrm_policy *xp) 3205{ 3206} 3207 3208static inline int security_xfrm_policy_delete(struct xfrm_policy *xp) 3209{ 3210 return 0; 3211} 3212 3213static inline int security_xfrm_state_alloc(struct xfrm_state *x, 3214 struct xfrm_user_sec_ctx *sec_ctx) 3215{ 3216 return 0; 3217} 3218 3219static inline int security_xfrm_state_alloc_acquire(struct xfrm_state *x, 3220 struct xfrm_sec_ctx *polsec, u32 secid) 3221{ 3222 return 0; 3223} 3224 3225static inline void security_xfrm_state_free(struct xfrm_state *x) 3226{ 3227} 3228 3229static inline int security_xfrm_state_delete(struct xfrm_state *x) 3230{ 3231 return 0; 3232} 3233 3234static inline int security_xfrm_policy_lookup(struct xfrm_policy *xp, u32 fl_secid, u8 dir) 3235{ 3236 return 0; 3237} 3238 3239static inline int security_xfrm_state_pol_flow_match(struct xfrm_state *x, 3240 struct xfrm_policy *xp, struct flowi *fl) 3241{ 3242 return 1; 3243} 3244 3245static inline int security_xfrm_decode_session(struct sk_buff *skb, u32 *secid) 3246{ 3247 return 0; 3248} 3249 3250static inline void security_skb_classify_flow(struct sk_buff *skb, struct flowi *fl) 3251{ 3252} 3253 3254#endif /* CONFIG_SECURITY_NETWORK_XFRM */ 3255 3256#ifdef CONFIG_KEYS 3257#ifdef CONFIG_SECURITY 3258static inline int security_key_alloc(struct key *key, 3259 struct task_struct *tsk, 3260 unsigned long flags) 3261{ 3262 return security_ops->key_alloc(key, tsk, flags); 3263} 3264 3265static inline void security_key_free(struct key *key) 3266{ 3267 security_ops->key_free(key); 3268} 3269 3270static inline int security_key_permission(key_ref_t key_ref, 3271 struct task_struct *context, 3272 key_perm_t perm) 3273{ 3274 return security_ops->key_permission(key_ref, context, perm); 3275} 3276 3277#else 3278 3279static inline int security_key_alloc(struct key *key, 3280 struct task_struct *tsk, 3281 unsigned long flags) 3282{ 3283 return 0; 3284} 3285 3286static inline void security_key_free(struct key *key) 3287{ 3288} 3289 3290static inline int security_key_permission(key_ref_t key_ref, 3291 struct task_struct *context, 3292 key_perm_t perm) 3293{ 3294 return 0; 3295} 3296 3297#endif 3298#endif /* CONFIG_KEYS */ 3299 3300#endif /* ! __LINUX_SECURITY_H */ 3301