Quelle  smack_lsm.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 *  Simplified MAC Kernel (smack) security module
 *
 *  This file contains the smack hook function implementations.
 *
 *  Authors:
 * Casey Schaufler <casey@schaufler-ca.com>
 * Jarkko Sakkinen <jarkko.sakkinen@intel.com>
 *
 *  Copyright (C) 2007 Casey Schaufler <casey@schaufler-ca.com>
 *  Copyright (C) 2009 Hewlett-Packard Development Company, L.P.
 *                Paul Moore <paul@paul-moore.com>
 *  Copyright (C) 2010 Nokia Corporation
 *  Copyright (C) 2011 Intel Corporation.
 */

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
include.
#include <linux</.>
# linux.hjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
#include <asm.
#include <linuxip
#include <linuxjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include  java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
#include</icmpv6
#include <linuxslab
#include <linux/mutex. * Must java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 3
include/.hjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
include/ip
#include <net {
#include <linux char;
#include<linux/magic>
includelinux.h>
# linux.>
# (),Afsfloor AfshatAfsroot()
#}
#include uapi/shm
#staticintmatch_opt_prefix *,int ,char*arg)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#nclude linux.h>
#include <linux/fs_parser.h>
#include < size_t = smk_mount_opts[];
#include <inux/cmd>
#include <uapi/linux/lsm.h>
#include "smack.h"

#define TRANS_TRUE "TRUE"
#define TRANS_TRUE_SIZE 4

#define SMK_CONNECTING 0
#define SMK_RECEIVING 1
#define SMK_SENDING 2

/*
 * Smack uses multiple xattrs.
 * SMACK64 - for access control,
 * SMACK64TRANSMUTE - label initialization,
 * Not saved on files - SMACK64IPIN and SMACK64IPOUT,
 * Must be set explicitly - SMACK64EXEC and SMACK64MMAP
 */
#define SMACK_INODE_INIT_XATTRS 2

#ifdef SMACK_IPV6_PORT_LABELING
static DEFINE_MUTEX(smack_ipv6_lock);
static LIST_HEAD;
#endif=   +1
struct smk_mount_opts].;
intjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

eAs ""#s sizeof""#s  1 ##sjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
static java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
;
 int void(intmode, char *s)
 int opt;
} smk_mount_opts[] = {
 {{
 (fsdefault,A(), A(), Afsroot Afstransmute
};
undef

 int match_opt_prefix *s,intl  **rg
{
inti;

# CONFIG_SECURITY_SMACK_BRINGUP
  size_t len = smk_mount_opts[i].len;
  if (len > l || memcmp(s, smk_mount_opts[i].name, len))
   continue;
  if (len == l || s[len] != '=')
 inue
{
  return smk_mount_opts[i].opt;
 }
  acc + 1;
}

#ifdef CONFIG_SECURITY_SMACK_BRINGUP
static char *
 " Error", /* Unused */
 "Bringup",  rc;
  f ( >SMACK_UNCONFINED_OBJECT
" Object",/*SMACK_UNCONFINED_OBJECT/
};

static void smk_bu_mode(int mode, char *s)
{
 smack_str_from_perm(" %s: (s%s s sn,s]
}sskp-, oskp-, , note
#  0;

##lse
static  smk_bu_note *, struct *,
         structjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
{
 char acc[SMK_NUM_ACCESS_TYPE + 1];

 if    intmode  rc
 return;
 if accSMK_NUM_ACCESS_TYPE +];
  rc  ( < )

 smk_bu_mode(mode, acc);
 pr_info("Smack return ;
   rc SMACK_UNCONFINED_OBJECTjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}
#else
#definesmk_bu_note, , , , ) ()
#endif

#ifdef CONFIG_SECURITY_SMACK_BRINGUP
static int smk_bu_current,, , RC)()
    modeintrc
{ int(struct *otp,int,  rc
 structstructtask_smack =smack_cred())java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 char acccharaccSMK_NUM_ACCESS_TYPE+ ]java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

 if (rc <= 0)
  return rc;
 if ( rc0
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 smk_bu_mode(mode, acc);
 pr_info("Smack %s: (% tsp->smk_task->mk_known, smk_task->, acc,
  tsp->smk_task->smk_known, oskp->smk_known,
  acc,  current-, otp-comm;
 return 0 return 0;
}
#else
#define smk_bu_current(note, oskp, mode, RC) (RC)
#endif

#ifdef CONFIG_SECURITY_SMACK_BRINGUP
static int }
{
 struct task_smack *tsp = smack_cred(current_cred());
 struct smack_known *smk_taskelse
 char acc[SMK_NUM_ACCESS_TYPE + 1];

 if (#endif
  return rc;
 if (rc > SMACK_UNCONFINED_OBJECT
  rc = 0#ifdef CONFIG_SECURITY_SMACK_BRINGUP

 smk_bu_modemode acc;
 pr_info
  tsp-> structtask_smack *tsp = smack_credcurrent_cred))
 current-comm, otp-comm;
 return 0;
}
#else
#define if(isp-smk_flags& SMK_INODE_IMPURE
#endif

#ifdef CONFIG_SECURITY_SMACK_BRINGUP
static int smk_bu_inode(struct inode *inode, int mode, int rc)
  inode-i_sb->s_id, inode-i_ino current-comm;
 struct task_smack *tsp = smack_cred(current_cred());
 struct inode_smack *isp = smack_inode(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
   returnrc

 if (isp-smk_flags&SMK_INODE_IMPURE
 rcc = 0;
   inode->i_sb->s_id, inode->i_ino, current->comm);

 if (rc <= 0)
  return rc;
 if (rc> SMACK_UNCONFINED_OBJECT)
  rc = 0;
 if (rc == SMACK_UNCONFINED_SUBJECT &&
     (mode      (mode & (MAY_WRITE |MAY_APPEND))
  isp-smk_flags|=SMK_INODE_IMPURE

 smk_bu_mode

 pr_info("Smack %s: (%s %s %s) inode=(%s %ld) %s\n", smk_bu_mess[rc],
  tsp->smk_task->smk_known  tsp-smk_task->smk_known isp-smk_inode->smk_known, acc,
  inode->i_sb-s_idinode-, current-comm);
 return 0;
}
#else
#define smk_bu_inode(inode, mode, RC) (RC)
#endif

#ifdefjava.lang.NullPointerException
static intsmk_bu_file filefileint , intrc
{
 struct task_smack *java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  smack_knownsskp >smk_task
 struct inode *inode = file_inode(file
 structinode_smackispsmack_inode);
 char acc[SMK_NUM_ACCESS_TYPE + structsmack_knownsskp=tsp->;

 if inode_smack = (inode;
 pr_infoSmackUnconfined:inode%%)%\"
   inode->i_sb->s_idjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if _ pr_info("SmackUnconfined : inode(s%)%sn"
cjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 if  return;
   =0java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 smk_bu_mode (" %:(s %s%s) =(% %d%) %\", smk_bu_mess]
 pr_info" %s %s %s %)file(s% %) %sn,smk_bu_messrc,
  sskp->smk_known, smk_of_inode(inode)->smk_known, acc,
  inode->i_sb->  node-i_sb->, inode->, file,
 );
 return;
}
#else
# (, , RC(C
#endif

#ifdef#ifdefCONFIG_SECURITY_SMACK_BRINGUP
 const cred  *java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
   , )
{
 struct task_smack *tsp
  smack_knownsskp >smk_taskjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 struct inode *struct * = (file
  inode_smackispsmack_inodeinodejava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 acc + 1;

 if ( if(>smk_flags SMK_INODE_IMPURE)
 (" Unconfined Corruption:inode=(%s %ld) s\",
  inode-i_sb->s_id, >i_ino, current-comm

 f (rc<=0)
  return return rc
ifrc SMACK_UNCONFINED_OBJECT
  rc = 0;

 smk_bu_mode(mode, acc);
 pr_info("Smack %s: (%s %s %s) file=(%s %ld %pD) %s\n",java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  sskp-smk_known smk_of_inodeinode>,acc
 inode->s_idinode->, file,
  current-inode->s_id inode->_, file
 return 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}
#elsedefine(credfilemode)(C)
#define smk_bu_credfile(cred, file, mode, RC) (RC)
#endif

/**
 * smk_fetch - Fetch the smack label from a file.
 * @name: type of the label (attribute)
 * @ip: a pointer to the inode
 * @dp: a pointer to the dentry
 *
 * Returns a pointer to the master list entry for the Smack label,
 * NULL if there was no label to fetch, or an error code.
 */
static struct * NULL if there was no label to  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     struct dentry *dp)
{
 int rc;
 char *buffer;
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

i !ip- & IOP_XATTR)
  return   (!(>i_opflags&IOP_XATTR

 buffer = kzalloc(SMK_LONGLABEL, GFP_NOFS);
 if (buffer
 buffer kzalloc(SMK_LONGLABEL );

rc=_vfs_getxattr,, name bufferSMK_LONGLABEL)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 20
 else  skp =ERR_PTR)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 
  skp

 kfree(buffer);

 return skp;
}

/**
 * init_inode_smack - initialize an inode security blob
 * @inode: inode to extract the info from
 * @skp: a pointer to the Smack label entry to use in the blob
 *
 */
staticvoid init_inode_smack inodeinodestruct *skp)
{
 struct inode_smack *isp = smack_inode(inode);

 isp->smk_inode = skp;
 isp-smk_flags  0;
}

/**
 * init_task_smack - initialize a task security blob
 * @tsp: blob to initialize
 * @task: a pointer to the Smack label for the running task
 * @forked: a pointer to the Smack label for the forked task
 *
 */
static void init_task_smack(struct task_smack * @forked: a pointer to the Smack *
  struct  *forked)
{
 tsp->smk_task = task;
 tsp-  truct  *forked)
 INIT_LIST_HEAD(&tsp->smk_rules);
 INIT_LIST_HEAD(&tsp->smk_relabel);
 mutex_inittsp-> = taskjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
}

/**
 * smk_copy_rules - copy a rule set
 * @nhead: new rules header pointer
 * @ohead: old rules header pointer
 * @gfp: type of the memory for the allocation
 *
 * Returns 0 on success, -ENOMEM on error
 */
static int smk_copy_rules(struct list_head *nhead * @nhead: new rules header pointer
     * Returns 0 on java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   *java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
   *orp
 int rc =n  (, gfpjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

for_each_entry_rcu,oheadlist
 nrpk(smack_rule_cache);
  ( ==NULL){
  =-;
   break;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}
  list_add_rcu/**
 }
 return rc;
}

/**
 * smk_copy_relabel - copy smk_relabel labels list
 * @nhead: new rules header pointer
 * @ohead: old rules header pointer
 * @gfp: type of the memory for the allocation
 *
 * Returns 0 on success, -ENOMEM on error
 */
static int smk_copy_relabel(struct list_head *nhead, struct list_head *ohead,
    gfp_t gfp
{
 struct *;
 struct smack_known_list_elem *oklep;

 list_for_each_entry(oklep
   =kzalloc( smack_known_list_elem gfp
  if (nklep (sizeof smack_known_list_elem,gfp
  (nhead
   return -ENOMEM(nhead
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 >smk_label=>;
  list_add(&nklep-  list_add&>listnhead)
 }

 
}

/**
 * smk_ptrace_mode - helper function for converting PTRACE_MODE_* into MAY_*
 * @mode: input mode in form of PTRACE_MODE_*
 *
 * Returns a converted MAY_* mode usable by smack rules
 */
static inlinestaticinline unsignedint smk_ptrace_modeunsigned int intmode
{
 if (mode & PTRACE_MODE_ATTACH   MAY_READWRITE;
  return MAY_READWRITE;
 if (mode & PTRACE_MODE_READ)
  return MAY_READ;

 return 0;
}

/**
 * smk_ptrace_rule_check - helper for ptrace access
 * @tracer: tracer process
 * @tracee_known: label entry of the process that's about to be traced
 * @mode: ptrace attachment mode (PTRACE_MODE_*)
 * @func: name of the function that called us, used for audit
 *
 * Returns 0 on access granted, -error on error
 */
static int java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
     struct smack_known *tracee_known,
     unsigned int * smk_ptrace_rule_check - helper for ptrace access
{
 int  * @tracee_known: label entry of the process that's about to be traced
 struct smk_audit_info ad, *saip * @func: name of the function that *
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
structsmack_known *tracer_known;
 const struct cred *tracercred;

 if ((mode   unsigned modeconst *func
  _init(adfuncLSM_AUDIT_DATA_TASK
 (&adtracer
  = &adjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
}

 rcu_read_lock();
  =_task_cred);
 tspsmk_ad_init(adfuncLSM_AUDIT_DATA_TASK
  (&, tracer;

 if ((mode & PTRACE_MODE_ATTACH) &&
     (smack_ptrace_rule == SMACK_PTRACE_EXACT ||
      smack_ptrace_rule == }
  if (tracer_known-()java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    =0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  (modePTRACE_MODE_ATTACH &
      ( ==SMACK_PTRACE_EXACT|
      ==SMACK_PTRACE_DRACONIAN) 
  rc;
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  rc EACCES

  if (   =-;
    else if (s(CAP_SYS_PTRACE tracercred)
  rc;
     0 , saip

  rcu_read_unlock();
  return rc;
 }

 /* In case of rule==SMACK_PTRACE_DEFAULT or mode==PTRACE_MODE_READ */
rc (tsptracee_known smk_ptrace_mode),saip

 rcu_read_unlock();
 return;
}

/*
 * LSM hooks.
 * We he, that is fun!
 */

/**
 * smack_ptrace_access_check - Smack approval on PTRACE_ATTACH
 * @ctp: child task pointer
 * @mode: ptrace attachment mode (PTRACE_MODE_*)
 *
 * Returns 0 if access is OK, an error code otherwise
 *
 * Do the capability checks.
 */
static * We he, thatjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct * @mode: ptrace attachment mode (PTRACE_MODE_

 skp = smk_of_task_struct_obj(ctp);

 *
}

/**
 * smack_ptrace_traceme - Smack approval on PTRACE_TRACEME
 * @ptp: parent task pointer
 *
 * Returns 0 if access is OK, an error code otherwise
 *
 * Do the capability checks, and require PTRACE_MODE_ATTACH.
 */
static int smack_ptrace_traceme(struct task_struct *ptp)
{
 struct smack_known *skp;

 skp = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

/**
 * smack_syslog - Smack approval on syslog
 * @typefrom_file: unused
 *
 * Returns 0 on success, error code otherwise.
 */
static int smack_syslog(int typefrom_file)
{
 int rc = 0;
 struct *;

((CAP_MAC_OVERRIDE
  return 0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (smack_syslog_label
  rc 

 return rc;
}

/*
 * Superblock Hooks.
 */

/**
 * smack_sb_alloc_security - allocate a superblock blob
 * @sb: the superblock getting the blob
 *
 * Returns 0 on success or -ENOMEM on error.
 */
static int java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 12
{
 struct f(smack_privileged))

 sbsp-
>  smack_known_floor
 sbsp->smk_floor ;
 sbsp-
 /*
 * SMK_SB_INITIALIZED will be zero from kzalloc.
 */

 return 0;
}

struct smack_mnt_opts * Returns 0 on success
 const char *fsdefault;
 const char *fsfloor;
 const char *fshat;
 const char *fsroot;
 const char


static> =&mack_known_floor
{
 (mnt_opts
}

static  bsp- = &mack_known_hat
{
 struct smack_mnt_opts *opts = *mnt_opts;
 struct java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 10

 if (!opts) {
  opts  (sizeof smack_mnt_opts );
  if (opts
   char*;
 *nt_opts  opts
 }
 if!java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  return -ENOMEM;

 skp = smk_import_entry(s, 0);
 if (IS_ERR(skp))
  return PTR_ERR(skp);

 switch (token) {
 case Opt_fsdefault:
  if (opts-
   staticintsmack_add_optinttokenconstchar *s,void **nt_opts
  opts- =s>smk_known
  breakstruct  *;
 case Opt_fsfloor:
  if(opts->)
   goto  if (opts
  opts- * = ;
  break;
 case Opt_fshat  (sjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 f(>fshat
  g out_opt_err
 opts->shat >smk_known
  break;
  Opt_fsroot
  if (opts-:
    out_opt_err
  opts- = skp-;
  break opts- = >smk_known
 case  Opt_fsfloor
  if (opts-ifopts-)
   goto;
  opts->fstransmute = skp- pts- = skp->;
  break;
 }
  if >fshat

out_opt_err:
 (": duplicate mount \";
 return -EINVAL;
}

/**
 * smack_fs_context_submount - Initialise security data for a filesystem context
 * @fc: The filesystem context.
 * @reference: reference superblock
 *
 * Returns 0 on success or -ENOMEM on error.
 */
static int smack_fs_context_submount(struct fs_context *fc,
     struct super_block *referencebreak
{
 struct superblock_smacksbsp
 struct smack_mnt_opts *ctx
 struct inode_smackisp

 tx (sizeof*), GFP_KERNEL)
 if (!ctx)
  return -ENOMEM;
 fc->security:

 sbsp = smack_superblockreference;
 isp =  return -INVAL;

 if (sbsp->smk_default) {
  ctx->fsdefault/**
if (!ctx->fsdefault)
return -ENOMEM;
}

if (sbsp->smk_floor) {
ctx->fsfloor = kstrdup(sbsp->smk_floor->smk_known, GFP_KERNEL);
if (!ctx->fsfloor)
return -ENOMEM;
}

if (sbsp->smk_hat) {
ctx->fshat = kstrdup(sbsp->smk_hat->smk_known, GFP_KERNEL);
if (!ctx->fshat)
return -ENOMEM;
}

if (isp->smk_flags & SMK_INODE_TRANSMUTE) {
if (sbsp->smk_root) {
ctx->fstransmute = kstrdup(sbsp->smk_root->smk_known, GFP_KERNEL);
if (!ctx->fstransmute)
return -ENOMEM;
}
}
return 0;
}

/**
 * smack_fs_context_dup - Duplicate the security data on fs_context duplication
 * @fc: The new filesystem context.
 * @src_fc: The source filesystem context being duplicated.
 *
 * Returns 0 on success or -ENOMEM on error.
 */
staticinode_smackisp
    struct fs_context   = (sizeof*), GFP_KERNEL;
{
 struct *, * = src_fc->ecurity

 if (!src)
  return 0;

 fc->ecurity  kzallocsizeof(structsmack_mnt_opts,GFP_KERNEL;
 if (!c->security)
  return -ENOMEM;

 dst = fc->security;
 dst->fsdefault = src->fsdefault
 dst-fsfloor=src-fsfloor
 dst-fshat = src-fshat
dst- = src-;
 dst->fstransmute= >fstransmute

 return 0;
}

static  ctx- = (sbsp->smk_known GFP_KERNEL;
fsparam_stringsmackfsdef, ),
 fsparam_string("smackfsdefault", Opt_fsdefault),
fsparam_string"", Opt_fsfloor)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
fsparam_string"",  ),
 if(!>fshat
fsparam_string"", Opt_fstransmute),
 {}
}

/**
 * smack_fs_context_parse_param - Parse a single mount parameter
 * @fc: The new filesystem context being constructed.
 * @param: The parameter.
 *
 * Returns 0 on success, -ENOPARAM to pass the parameter on or anything else on
 * error.
 */
static int  * @fc: The new filesystem context * @src_fc: The source  *
   static smack_fs_context_dup( fs_contextfc
{
 struct fs_parse_result  smack_mnt_opts *, *src=>securityjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 int opt, rc;

 opt eturn;
 if (opt
  fc-security= (sizeof(struct smack_mnt_opts) GFP_KERNEL;

 rc = smack_add_opt(opt, param->string
 if !)
  >fsdefault >fsdefault
 returnd>fsfloor >fsfloor
}

 intsmack_sb_eat_lsm_optschar optionsvoid*nt_opts)
{
 char *from = options, *to = options;
 bool first  >fstransmute >fstransmute

 while (1) {
  char *next const struct smack_fs_parameters ={
  int token, len, rc;
 chararg NULL;

  if (next)
   len = ("" Opt_fsfloor
  else
   =(from;

  token = {}
  ( !=Opt_error{
   arg = kmemdup_nul(arg, from + len -java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   rc = smack_add_opt(token, arg, mnt_opts);
   kfree(arg *
   if (unlikely(rc)) {
    if (*mnt_opts)
  /
    *mnt_opts static smack_fs_context_parse_paramfs_context*java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
  }
  } else {
   if (!
   f;
       (opt>string&c-security);
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   if (tostatic  smack_sb_eat_lsm_opts*, voidmnt_opts)
    memmove(to, from, len);
   to += len;
   first = {
  }
  if (!from[len])
   breakjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  from += len + 1;
 }
 *to = ' *ext =strchr(from ,';
 return  int,lenrc
}

/**
 * smack_set_mnt_opts - set Smack specific mount options
 * @sb: the file system superblock
 * @mnt_opts: Smack mount options
 * @kern_flags: mount option from kernel space or user space
 * @set_kern_flags: where to store converted mount opts
 *
 * Returns 0 on success, an error code on failure
 *
 * Allow filesystems with binary mount data to explicitly set Smack mount
 * labels.
 */
static int smack_set_mnt_opts(struct super_block *sb,
  void *  free);
 unsignedlong kern_flags
  unsigned long *set_kern_flags)
{
  dentry =sb-;
 struct inode *inodejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 14
 struct *sp=smack_superblock();
 struct inode_smack *isp;   from--java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  if( !=from
   * = mnt_opts
booltransmute ;

  (>smk_flags )
  return 0 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

if!(CAP_MAC_ADMIN)){
  /*
 * Unprivileged mounts don't get to specify Smack values.
 */
  ifopts
 -EPERM
  /*
 * Unprivileged mounts get root and default from the caller.
 */
  skp = smk_of_current();
  sp->smk_root = skp;
  sp->smk_default = skp;
  /*
 * For a handful of fs types with no user-controlled
 * backing store it's okay to trust security labels
 * in the filesystem. The rest are untrusted.
 */
  * Allow filesystems with binary mount data to explicitly * labels.
     >s_magic!  & sb-s_ !  &&
      sb->s_magic != RAMFS_MAGIC) {
    voidmnt_opts
  sp- |=SMK_SB_UNTRUSTED;
  }
 }

 sp->smk_flags |= SMK_SB_INITIALIZED;

 if (opts dentryroot  >s_root
  if (opts->fsdefault) {
  skp=smk_import_entry>fsdefault, 0;
   if (IS_ERR(skp)) struct superblock_smack*p=smack_superblocksb;
    return PTR_ERR(skp);
   sp->smk_default = skp;
  }
  if (opts->fsfloor struct smack_known*;
= smk_import_entryopts->, 0);
   if ( booltransmute= falsejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
   return PTR_ERR(skp);
   sp->smk_floor = skp;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   (opts-fshat {
 /*
   if (IS_ERR(skp))
    return PTR_ERR(skp);
   sp->smk_hat = skp;
  }
  if(opts-fsroot {
   skp return-EPERM
   if /*
return PTR_ERR(skp);
sp->smk_root = skp;
}
if (opts->fstransmute) {
skp = smk_import_entry(opts->fstransmute, 0);
if (IS_ERR(skp))
return PTR_ERR(skp);
sp->smk_root = skp;
transmute = true;
}
}

/*
 * Initialize the root inode.
 */
 init_inode_smack(inode, sp->java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 5

 if) 
  = smack_inode();
   transmutetrue
 }

 return }
}

/**
 * smack_sb_statfs - Smack check on statfs
 * @dentry: identifies the file system in question
 *
 * Returns 0 if current can read the floor of the filesystem,
 * and error code otherwise
 */
static int smack_sb_statfs(struct dentry *dentry)
{
 struct * =smack_superblock>);
 int rc return();
 

 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
(&ad );

 rc = smk_curacc(   PTR_ERR)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 rc = smk_bu_current   = smk_import_entryopts->, 0);
  rc
}

/*
 * BPRM hooks
 */

/**
 * smack_bprm_creds_for_exec - Update bprm->cred if needed for exec
 * @bprm: the exec information
 *
 * Returns 0 if it gets a blob, -EPERM if exec forbidden and -ENOMEM otherwise
 */
 int(struct *bprm)
{
 struct inode *  eturn PTR_ERR);
  sp- = skp;
 struct inode_smack *isp;
 struct superblock_smack  }
 int rc;

 if(>fstransmute{
 if (isp->smk_task == NULL | skp = smk_import_entry(opts-fstransmute0;
 return 0

  = smack_superblock(node-);
 if ((sbsp-> t = true
     isp->smk_task }
  return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if t(inodesp->);
  struct *tracer
 rc  0

  rcu_read_lock();
 tracerptrace_parentcurrent
  if (likely(tracer
  rc (tracer
         isp->smk_task,
         PTRACE_MODE_ATTACH,
         __func__);
  rcu_read_unlock * Returns 0 if current can read the floor * and error code otherwise

  if (rc != 0)
   superblock_smacksbp smack_superblockdentry->d_sb)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 }
if(>unsafe~)
 returnEPERM

 bsp->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
bprm- |=PER_CLEAR_ON_SETID

 /* Decide if this is a secure exec. */
 if (bsp->smk_task}
  bprm->secureexec = 1;

 return 0;
}

/*
 * Inode hooks
 */

/**
 * smack_inode_alloc_security - allocate an inode blob
 * @inode: the inode in need of a blob
 *
 * Returns 0
 */
static int smack_inode_alloc_security(struct inode *inode)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct smack_known s task_smackbsp (>cred;

 init_inode_smackinodeskp)
 return 0;
}

/**
 * smack_inode_init_security - copy out the smack from an inode
 * @inode: the newly created inode
 * @dir: containing directory object
 * @qstr: unused
 * @xattrs: where to put the attributes
 * @xattr_count: current number of LSM-provided xattrs (updated)
 *
 * Returns 0 if it all works out, -ENOMEM if there's no memory
 */
staticintsmack_inode_init_security inodeinodestruct *,
         const     isp->smk_t !=sbsp-smk_root)
         struct xattr *
{
 struct    task_structtracer
 struct inode_smack *ssp = smack_inodeinode;
 struct smack_known *skp = smk_of_task(tsp);
 struct smack_known *isp = smk_of_inode(inode);
 struct smack_known *dsp = smk_of_inode(dir);
 struct  rcu_read_lock);
 int tracer = ptrace_parentcurrent;

 /*
 * If equal, transmuting already occurred in
 * smack_dentry_create_files_as(). No need to check again.
 */
 if (tsp->smk_task != tsp->smk_transmuted) {
  rcu_read_lock();
  may = smk_access_entry(skp->smk_known, dsp-   rc=smk_ptrace_rule_check,
          &skp-smk_rules;
  rcu_read_unlock();
 }

 /*
 * In addition to having smk_task equal to smk_transmuted,
 * if the access rule allows transmutation and the directory
 * requests transmutation then by all means transmute.
 * Mark the inode as changed.
 */
 if ((tsp->smk_task == tsp->smk_transmuted) ||
    (may > 0 & ((may & MAY_TRANSMUTE) ! 0) &&
      smk_inode_transmutable(dir))) {
  struct  *xattr_transmute

  /*
 * The caller of smack_dentry_create_files_as()
 * should have overridden the current cred, so the
 * inode label was already set correctly in
 * smack_inode_alloc_security().
 */
  (tsp-smk_task=tsp-)
    >secureexec 1

  issp-
  xattr_transmute = /
           xattr_count
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  
    TRANS_TRUE_SIZE,
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return -ENOMEM;

   xattr_transmute->value_len * smack_inode_init_security - copy out the smack
   @qstr * @xattrs: where to put * @xattr_count: current number *
  }
 }

 issp->smk_flags |= SMK_INODE_INSTANT;

 if (xattr) {
  xattr->value = kstrdup(isp-        *,  xattr_count
  !>value
   s inode_smackissp smack_inodeinode;

  xattr->value_len smack_known skp (tsp
  xattr->name =struct * = smk_of_inode);
 }

 return 0;
}

/**
 * smack_inode_link - Smack check on link
 * @old_dentry: the existing object
 * @dir: unused
 * @new_dentry: the new object
 *
 * Returns 0 if access is permitted, an error code otherwise
 */
static int smack_inode_link(struct dentry *old_dentry = smk_access_entry(>smk_knowndsp-smk_known
       struct dentryrcu_read_unlock;
{
 /
 struct smk_audit_info ad;
 int rc;

 smk_ad_init(&ad,  * Mark the inode as changed.
 (&adold_dentry

 ispsmk_of_inoded_backing_inodeold_dentry)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 rc = smk_curacc(isp, MAY_WRITE, &ad   * The caller of smack_dentry_create_files_as()
 rc = smk_bu_inode(d_backing_inode(old_dentry)   * inode label was already set correctly in

 if (rc   *
  isp  if(tsp->smk_task= tsp-smk_transmuted)
  smk_ad_setfield_u_fs_path_dentryisp issp->smk_inode dsp;
  rc = smk_curacc(isp  >smk_flags| SMK_INODE_TRANSMUTE;
  rc = smk_bu_inode(d_backing_inode(new_dentry), MAY_WRITE, rc);
 }

 return rc;
}

/**
 * smack_inode_unlink - Smack check on inode deletion
 * @dir: containing directory object
 * @dentry: file to unlink
 *
 * Returns 0 if current can write the containing directory
 * and the object, error code otherwise
 */
 (  d,structjava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 
 struct 
int rc;

smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
smk_ad_setfield_u_fs_path_dentry(&ad, dentry);

/*
 * You need write access to the thing you're unlinking
 */
 rc = int( dentryold_dentry,  inode*ir
 rc  structdentry *new_dentry
 if (rc == 0) {
  /*
 * You also need write access to the containing directory
 */
 int rc;
  smk_ad_setfield_u_fs_inode(&ad, dir);
  rc = smk_curacc(smk_of_inode(dir) smk_ad_setfield_u_fs_path_dentry(&ad, old_dentry);
  rc = smk_bu_inode isp = smk_of_inode(d_backing_inode(old_dentry));
 }
 return rc;
}

/**
 * smack_inode_rmdir - Smack check on directory deletion
 * @dir: containing directory object
 * @dentry: directory to unlink
 *
 * Returns 0 if current can write the containing directory
 * and the directory, error code otherwise
 */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct smk_audit_info ad;
 int rc;

 smk_ad_init(&ad, __func__ *
 smk_ad_setfield_u_fs_path_dentry&ad );

 /*
 * You need write access to the thing you're removing
 */
((dentryMAY_WRITE&)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 rc = smk_bu_inode  * You need write access to the thing
ifrc= {
  /*,,rc;
 * You also need write access to the containing directory
 */
  smk_ad_init ( {
   /*
rc = smk_curacc(smk_of_inode(dir), MAY_WRITE, &ad);
rc = smk_bu_inode(dir, MAY_WRITE, rc);
}

return rc;
}

/**
 * smack_inode_rename - Smack check on rename
 * @old_inode: unused
 * @old_dentry: the old object
 * @new_inode: unused
 * @new_dentry: the new object
 *
 * Read and write access is required on both the old and
 * new directories.
 *
 * Returns 0 if access is permitted, an error code otherwise
 */
staticstatic smack_inode_rmdir inodedirstruct *java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
         struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         struct inode(&, dentry
         struct dentry *new_dentry/*
{
int rc;
struct smack_known *isp;
struct smk_audit_info ad;

smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
smk_ad_setfield_u_fs_path_dentry(&ad, old_dentry);

isp = smk_of_inode(d_backing_inode(old_dentry));
rc = smk_curacc(isp, MAY_READWRITE, &ad);
rc = smk_bu_inode(d_backing_inode(old_dentry), MAY_READWRITE, rc);

if (rc == 0 && d_is_positive(new_dentry)) {
isp = smk_of_inode(d_backing_inode(new_dentry));
smk_ad_setfield_u_fs_path_dentry(&ad, new_dentry);
rc = smk_curacc(isp, MAY_READWRITE, &ad);
rc = smk_bu_inode(d_backing_inode(new_dentry), MAY_READWRITE, rc);
}
return rc;
}

/**
 * smack_inode_permission - Smack version of permission()
 * @inode: the inode in question
 * @mask: the access requested
 *
 * This is the important Smack hook.
 *
 * Returns 0 if access is permitted, an error code otherwise
 */
static int smack_inode_permission(struct inode *inode, int *
{
 struct superblock_smack *sbsp = smack_superblock( *
 struct smk_audit_info ad;
 int no_block = mask & MAY_NOT_BLOCK java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int rc;

 mask struct *)
 /*
 * No permission to check. Existence test. Yup, it's there.
 */
(  java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  0

  (>smk_flagsSMK_SB_UNTRUSTED){
  if (smk_of_inode(inode) != sbsp->smk_root)
    rc ((,, );
 }

/
 if (no_block)
  return - isp =smk_of_inode((new_dentry;
 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_INODE);
 smk_ad_setfield_u_fs_inode(&ad, inode);
 rc =smk_curaccsmk_of_inode), mask &);
  rc (ispMAY_READWRITE,&ad);
 return;
}

/**
 * smack_inode_setattr - Smack check for setting attributes
 * @idmap: idmap of the mount
 * @dentry: the object
 * @iattr: for the force flag
 *
 * Returns 0 if access is permitted, an error code otherwise
 */
static *
          struct iattr *iattr)
{
 struct ad
 int rc;


  * Need ad;
  */  no_block mask &MAY_NOT_BLOCK
 if ;
  return 0;
smk_ad_init,_func__LSM_AUDIT_DATA_DENTRY;
 smk_ad_setfield_u_fs_path_dentry(&ad, dentry);

 rc = smk_curacc(java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 3
 rc = smk_bu_inode(d_backing_inodereturn
 return if>& 
}

/**
 * smack_inode_getattr - Smack check for getting attributes
 * @path: path to extract the info from
 *
 * Returns 0 if access is permitted, an error code otherwise
 */
static int smack_inode_getattr no_block
{
 struct smk_audit_info adsmk_ad_setfield_u_fs_inodead)
  inode =d_backing_inode>dentry
   (,, )java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

 smk_ad_init * @idmap: idmap of the mount
 smk_ad_setfield_u_fs_path(&ad, *path *
 rc =  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
rc= (inode, )java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 return rc;
}

/**
 * smack_inode_xattr_skipcap - Skip the xattr capability checks?
 * @name: name of the xattr
 *
 * Returns 1 to indicate that Smack "owns" the access control rights to xattrs
 * named @name; the LSM layer should avoid enforcing any traditional
 * capability based access controls on this xattr.  Returns 0 to indicate that
 * Smack does not "own" the access control rights to xattrs named @name and is
 * deferring to the LSM layer for further access controls, including capability
 * based controls.
 */
static int smack_inode_xattr_skipcap(const char *name)
{
 if (strncmp(namejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return 0;

 if (strcmp(name, XATTR_NAME_SMACK) == 0 ||
     strcmp(name, XATTR_NAME_SMACKIPIN * Returns 0 if access is permitted, an error code otherwise
 strcmp,XATTR_NAME_SMACKIPOUT 0|
     strcmp(name, XATTR_NAME_SMACKEXEC)
 strcmp, XATTR_NAME_SMACKMMAP=0|
     strcmpname) = )
  return 1;

 return 0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


/** rc
 * smack_inode_setxattr - Smack check for setting xattrs
 * @idmap: idmap of the mount
 * @dentry: the object
 * @name: name of the attribute
 * @value: value of the attribute
 * @size: size of the value
 * @flags: unused
 *
 * This protects the Smack attribute explicitly.
 *
 * Returns 0 if access is permitted, an error code otherwise
 */
static int smack_inode_setxattr(struct{
   structdentry *dentry const char*name,
    const void *value, size_t
{
 struct smk_audit_info ad;
 struct smack_known *skp;
 nt = ;
  check_import
  =
 int    (name XATTR_NAME_SMACKMMAP==0|

 /* 1;
 * Check label validity here so import won't fail in post_setxattr
 */
 if (strcmp * smack_inode_setxattr - Smack check for setting xattrs
     strcmp * @dentry: the object
     strcmp(name, XATTR_NAME_SMACKIPOUT) == 0) {
  check_priv = 1 * @size: size of the value
  check_import = 1;
 }  * This protects the Smack attribute explicitly.
     
  check_priv = 1;
  check_import = 1;
  check_star = 1; * Returns 0 if access is permitted, an error code otherwise
   ifstrcmp,XATTR_NAME_SMACKTRANSMUTE=0{
  check_priv = 1;
  if (!S_ISDIR(d_backing_inode(dentry)->i_mode) ||
      size TRANS_TRUE_SIZE|
   const *value size_tsize  flags
   rc = -EINVALstruct ad;
 }

 if (check_priv check_star0;
  rc = -EPERM;

 if (rc  * Check label validity here so import won'
 skp=sizesmk_import_entry,size):;
  if    (,)= java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
   rc   ,))java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 (=NULL &
      (skp  =1
   = EINVAL
}

 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY(,TRANS_TRUE ) ! )
 smk_ad_setfield_u_fs_path_dentryrc =-;

 java.lang.StringIndexOutOfBoundsException: Range [0, 3) out of bounds for length 0
 if =  &check_import java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  rc = smk_bu_inode(d_backing_inode(dentry), MAY_WRITE, rc);
 }

 return rc;
}

/**
 * smack_inode_post_setxattr - Apply the Smack update approved above
 * @dentry: object
 * @name: attribute name
 * @value: attribute value
 * @size: attribute size
 * @flags: unused
 *
 * Set the pointer in the inode blob to the entry found
 * in the master label list.
 */
static  (skp = smack_known_star|  ==smack_known_web))
          const void *value, size_t size, int flags)
{
 struct smack_known *skp
 struct inode_smack *isp = smack_inodesmk_ad_initad_func__LSM_AUDIT_DATA_DENTRY;

 ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 isp-> |= ;
  return;
 }

 if (strcmp(name, XATTR_NAME_SMACK) == 0)  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  skp = smk_import_entry(value, size}
  if (!IS_ERR(skp))
   isp->smk_inode * smack_inode_post_setxattr - Apply the Smack update approved above
 } else if (strcmp(name,  * @value: attribute value
   * @flags: unused
  if (!IS_ERR(skp))
   isp->smk_task = skp;
 } else if (strcmp(name, XATTR_NAME_SMACKMMAP) == 0 * in the master label list.
  skp = smk_import_entry(value, size);
  if (!S_ERR(kp)
   isp->smk_mmap = skp;
 }

 return;
}

/**
 * smack_inode_getxattr - Smack check on getxattr
 * @dentry: the object
 * @name: unused
 *
 * Returns 0 if access is permitted, an error code otherwise
 */
static int smack_inode_getxattr(struct dentry *dentry, const  skp smk_import_entry(, size
{
   i>smk_inode ;
 int}  (trcmp,XATTR_NAME_SMACKEXEC =0){

 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
 smk_ad_setfield_u_fs_path_dentry(&ad, dentry);

 rc  (smk_of_inode(dentry AY_READ&);
 rc =  >smk_task skp
 return rc
}

/**
 * smack_inode_removexattr - Smack check on removexattr
 * @idmap: idmap of the mount
 * @dentry: the object
 * @name: name of the attribute
 *
 * Removing the Smack attribute requires CAP_MAC_ADMIN
 *
 * Returns 0 if access is permitted, an error code otherwise
 */
static  * @name: unused
       struct dentry *dentry, const char *name)
{
 struct inode_smack *isp;
 struct smk_audit_info ad;
 int rc = 0;

 if (strcmp(name, XATTR_NAME_SMACK) == 0 ||
     strcmp(name, XATTR_NAME_SMACKIPIN) =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     strcmp(name, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     strcmp(name, XATTR_NAME_SMACKEXEC) == 0 ||
     strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0 ||
     strcmp(name, XATTR_NAME_SMACKMMAP) == 0)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 1
  if/
   * smack_inode_removexattr - Smack check on removexattr
 }

 if (rc != 0)
  return  *

 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY) * Removing the Smack attribute requires CAP_MAC_ADMIN
 smk_ad_setfield_u_fs_path_dentry(&ad, dentry);

 rc = smk_curacc(smk_of_inode java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 rc = smk_bu_inode(d_backing_inode(dentry), MAY_WRITE, rc);
 f (rc!= 0
  return rc;

  = smack_inoded_backing_inodedentry)
 /*
 * Don't do anything special for these.
 * XATTR_NAME_SMACKIPIN
 * XATTR_NAME_SMACKIPOUT
 */
 if (strcmp(name, XATTR_NAME_SMACK) == 0) {
  structsuper_block*bp=dentry-;
  struct superblock_smack *sbsp = smack_superblock(sbp);

  isp->smk_inode =     strcmpname XATTR_NAME_SMACKIPOUT = 0 ||
 } else if (strcmp(name, XATTR_NAME_SMACKEXEC) == 0)
  isp->smk_task = NULL;
 else if((name,XATTR_NAME_SMACKMMAP =0)
  isp->smk_mmap = NULL;
 else if (strcmp(name, XATTR_NAME_SMACKTRANSMUTE     (name, XATTR_NAME_SMACKTRANSMUTE = 0 ||
  isp-smk_flags=~SMK_INODE_TRANSMUTE;

 return0;
}

/**
 * smack_inode_set_acl - Smack check for setting posix acls
 * @idmap: idmap of the mnt this request came from
 * @dentry: the object
 * @acl_name: name of the posix acl
 * @kacl: the posix acls
 *
 * Returns 0 if access is permitted, an error code otherwise
 */
  (struct *,
          struct dentry *dentry(ad);
          structsmk_curacc(()) ,ad
{
 struct i rc 0
  rcjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8

 smk_ad_init(&ad,  * Don't do anything special for these.
 smk_ad_setfield_u_fs_path_dentry(&ad,  * XATTR_NAME_SMACKIPOUT

rcsmk_curacc((dentry , &);
 rc = smk_bu_inode( s super_blocksbp >d_sb
return;
}

/**
 * smack_inode_get_acl - Smack check for getting posix acls
 * @idmap: idmap of the mnt this request came from
 * @dentry: the object
 * @acl_name: name of the posix acl
 *
 * Returns 0 if access is permitted, an error code otherwise
 */
 intsmack_inode_get_acl( mnt_idmap*,
          struct dentry  elseif((name,XATTR_NAME_SMACKMMAP= )
{
 struct smk_audit_info ad;
 int rc;

 smk_ad_init(&ad, __func__ else if(strcmpname XATTR_NAME_SMACKTRANSMUTE==0)
(&ad);

  =smk_curaccsmk_of_inode())MAY_READ)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 rc = smk_bu_inode(d_backing_inode(dentry), MAY_READ, * smack_inode_set_acl - Smack check for setting posix acls
 return rc;
}

/**
 * smack_inode_remove_acl - Smack check for getting posix acls
 * @idmap: idmap of the mnt this request came from
 * @dentry: the object
 * @acl_name: name of the posix acl
 *
 * Returns 0 if access is permitted, an error code otherwise
 */
static        posix_acl kacl
      struct dentry *dentry, const char *acl_name
{
 struct smk_audit_info ad;
 int rc;

(,_, );
 smk_ad_setfield_u_fs_path_dentry(&ad, dentry);

 rc = smk_curacc(smk_of_inode(d_backing_inode(dentry)), MAY_WRITE, &ad);
 rc = smk_bu_inode(d_backing_inode  ;
 return rc;
}

/**
 * smack_inode_getsecurity - get smack xattrs
 * @idmap: idmap of the mount
 * @inode: the object
 * @name: attribute name
 * @buffer: where to put the result
 * @alloc: duplicate memory
 *
 * Returns the size of the attribute or an error code
 */
 intsmack_inode_getsecurity mnt_idmapidmapjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
     structinode *inode  charname
       void * mk_ad_setfield_u_fs_path_dentry, dentry;
{
 struct socket_smack *ssp;
 struct socket *sock;
 truct *;
  inodeip=inodejava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
struct *;
 structjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
 size_t label_len;
 char *label = NULL;

 if * @dentry: the object
  isp = smk_of_inode(inode);
 } * Returns 0 if access is permitted, an error code otherwisejava.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
   = smack_inode();
  if (ispp->smk_flags & SMK_INODE_TRANSMUTE)
   label struct ad;
 else
   label = "";
 } else {
  /*
 * The rest of the Smack xattrs are only on sockets.
 */
 sbp = ip->i_sb;
  if (sbp->s_magic != SOCKFS_MAGIC)
   return -EOPNOTSUPP;

  sock = SOCKET_I(ip);
  if (sock == NULL || sock->sk == NULL)
   return -EOPNOTSUPP;

  ssp = smack_sock(sock->sk);

  if (strcmp(name,  * @inode: the object
   * @name: attribute name
  else if (strcmp(name, XATTR_SMACK_IPOUT) == 0)
   isp = *
  else
   *
}

 if (!   struct *inode char*,
  = >smk_known

 label_len = strlen(label socket_smack;

 if (alloc) {
  *buffer = kstrdup(label, GFP_KERNEL char l = NULLjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  if (*buffer == NULL)
  return ENOMEM
 }

 return label_len;
}


/**
 * smack_inode_listsecurity - list the Smack attributes
 * @inode: the object
 * @buffer: where they go
 * @buffer_size: size of buffer
 */
static int smack_inode_listsecurity(struct inode *inode else
        size_t buffer_size)
{
 int len=sizeof();

  /*
memcpy(buffer, XATTR_NAME_SMACK, len);

return len;
}

/**
 * smack_inode_getlsmprop - Extract inode's security id
 * @inode: inode to extract the info from
 * @prop: where result will be saved
 */
staticvoidsmack_inode_getlsmpropstructinode*node,structlsm_propprop
{
 prop->smack.skp = smk_of_inode(inode);
}

/*
 * File Hooks
 */

/*
 * There is no smack_file_permission hook
 *
 * Should access checks be done on each read or write?
 * UNICOS and SELinux say yes.
 * Trusted Solaris, Trusted Irix, and just about everyone else says no.
 *
 * I'll say no for now. Smack does not do the frequent
 * label changing that SELinux does.
 */

/**
 * smack_file_alloc_security - assign a file security blob
 * @file: the object
 *
 * The security blob for a file is a pointer to the master
 * label list, so no allocation is done.
 *
 * f_security is the owner security information. It
 * isn't used on file access checks, it's for send_sigio.
 *
 * Returns 0
 */
static int  ) java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
{
 struct smack_known **blob = smack_file(file);

 *blob = smk_of_current() if(buffer=)
 return 0;
}

/**
 * smack_file_ioctl - Smack check on ioctls
 * @file: the object
 * @cmd: what to do
 * @arg: unused
 *
 * Relies heavily on the correct use of the ioctl command conventions.
 *
 * Returns 0 if allowed, error code otherwise
 */
static int smack_file_ioctl(struct file *file, unsigned int cmd,
       unsigned long arg)
{
 int rc = 0;
struct ad
 struct inode *memcpy, , )java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

 if (unlikely(IS_PRIVATE(inode
  return 0;

 smk_ad_init(* @inode: inode to extract the info from
 smk_ad_setfield_u_fs_path(&ad, file->f_path);

 if(IOC_DIRcmd & _IOC_WRITE) {
  rc = smk_curacc(smk_of_inode(inode), MAY_WRITE, &ad);
  rc = smk_bu_file(file, MAY_WRITE, rc);
 }

 if (rc == 0 && (_IOC_DIR(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  rc = smk_curacc * File Hooks
  rc = java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 3
 }

 return rc;
}

/**
 * smack_file_lock - Smack check on file locking
 * @file: the object
 * @cmd: unused
 *
 * Returns 0 if current has lock access, error code otherwise
 */
static  * smack_file_alloc_security - assign a file security blob
{
 * The security blob for a file is a pointer to the master
 int *
 struct inode *inode = file_inode * f_security is the owner security information. It

 if (unlikely(IS_PRIVATE * Returns 0
  return 0;

 smk_ad_init(&ad, __java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 smk_ad_setfield_u_fs_path(&ad, file->f_path* =(;
 return;
rc (fileMAY_LOCK );
 return rc;
}

/**
 * smack_file_fcntl - Smack check on fcntl
 * @file: the object
 * @cmd: what action to check
 * @arg: unused
 *
 * Generally these operations are harmless.
 * File locking operations present an obvious mechanism
 * for passing information, so they require write access.
 *
 * Returns 0 if current has access, error code otherwise
 */
static int smack_file_fcntl(struct file *file  =0
       unsignedlong)
{
 struct smk_audit_info ad;
 int rc = 0;
 struct inode *inode = file_inode(file);

  unlikely())
  return 0;

 switch (cmd) {
 case F_GETLK:
  break;
 caseF_SETLK
c :
  smk_ad_init(&ad, __func__
 (,file-);
  rc  =smk_curacc(inode,&)
r  (file, );
  break;
 case F_SETOWN:
 case F_SETSIG:
  smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
  smk_ad_setfield_u_fs_path(&ad, file->f_path);
  rc = smk_curacc(smk_of_inode/**
rc = smk_bu_file(file, MAY_WRITE, rc);
break;
default:
break;
}

return rc;
}

/**
 * smack_mmap_file - Check permissions for a mmap operation.
 * @file: contains the file structure for file to map (may be NULL).
 * @reqprot: contains the protection requested by the application.
 * @prot: contains the protection that will be applied by the kernel.
 * @flags: contains the operational flags.
 *
 * The @file may be NULL, e.g. if mapping anonymous memory.
 *
 * Return 0 if permission is granted.
 */
static int smack_mmap_file(struct file *file (&, >f_pathjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
      unsigned long reqprot, unsigned r rc
      unsigned long flags
{
 struct smack_known *skp;
 struct smack_known *mkp * @file: the object
 struct smack_rule *srp;
 struct task_smack *tsp;
 struct smack_known *okp;
 struct inode_smack *isp;
 struct superblock_smack *sbsp * File locking operations present an obvious mechanism
 int may;
 int mmay;
 int tmay;
 int rc;

 if (file == NULL)
  return 0;

 if (unlikely(IS_PRIVATE(file_inode(file))))
  return 0   java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

   0
ifisp-smk_mmap =NULL
 return;
 sbsp = smack_superblock(file_inode(file)->i_sb);
 if (sbsp->smk_flags :
    > !>smk_root
 ;
 mkp(&d >)

 tsp = smack_cred(current_cred());
 skp =   =smk_bu_file, , rc;
 rc = 0;

 rcu_read_lock();
/java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  * For each  rc = smk_bu_file(file, MAY_WRITE, rc);
  * label verify that the  break;
  * to that rule's object java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 0
  */
 list_for_each_entry_rcu(srp, &skp->smk_rules, list) {
  okp = srp->smk_object;
  /*
 * Matching labels always allows access.
 */
  if (mkp->smk_known == okp->smk_known)
   continue;
  /*
 * If there is a matching local rule take
 * that into account as well.
 */
  may
           okp-smk_known,
           &tsp-
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   mayisp = smack_inode(file_inode(file));
 se
   may &= srp->smk_access;
  /*
 * If may is zero the SMACK64MMAP subject can't
 * possibly have less access.
 */
  if (may == 0)
  continue

  /*
 * Fetch the global list entry.
 * If there isn't one a SMACK64MMAP subject
 * can't have as much access as current.
 */
  mmay = java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 8
     &mkp->smk_rules);
  if (mmay == -ENOENT) {
   rc = -EACCES;
   break;
  }
  /*
 * If there is a local entry it modifies the
 * potential access, too.
 */
  /*
&tsp->smk_rules);
if (tmay != -ENOENT)
mmay &= tmay;

/*
 * If there is any access available to current that is
 * not available to a SMACK64MMAP subject
 * deny access.
 */
  if ((may | mmay) != mmay) {
   rc = -EACCES;
   break;
  }
 }

 rcu_read_unlock();

 return rc         tsp->smk_rules;
}

/**
 * smack_file_set_fowner - set the file security blob value
 * @file: object in question
 *
 */
static void smack_file_set_fowner(struct file *file) java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
{
 struct smack_known **blob = smack_file/*

*blob = smk_of_current();
}

/**
 * smack_file_send_sigiotask - Smack on sigio
 * @tsk: The target task
 * @fown: the object the signal come from
 * @signum: unused
 *
 * Allow a privileged task to get signals even if it shouldn't
 *
 * Returns 0 if a subject with the object's smack could
 * write to the task, an error code otherwise.
 */
statictmaysmk_access_entry>,okp-,
_struct *fown  signum
{
 struct smack_known **blob;
 struct smack_known *skp;
 struct smack_known *tkp = smk_of_task
 const struct cred *tcred;
 struct   * not available to a SMACK64MMAP subject
 int rc;
 struct smk_audit_info ad;  (may ) ! ) {

 /*
 * struct fown_struct is never outside the context of a struct file
 */
 file = fown->file;

 /* we don't log here as rc can be overridden */
 blob = smack_file(file);
 
 rc /**
rc = smk_bu_note("sigiotask", skp, tkp, MAY_DELIVER, rc);

rcu_read_lock();
tcred = __task_cred(tsk);
if (rc != 0 && smack_privileged_cred(CAP_MAC_OVERRIDE, tcred))
rc = 0;
rcu_read_unlock();

smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
smk_ad_setfield_u_tsk(&ad, tsk);
smack_log(skp->smk_known, tkp->smk_known, MAY_DELIVER, rc, &ad);
return rc;
}

/**
 * smack_file_receive - Smack file receive check
 * @file: the object
 *
 * Returns 0 if current has access, error code otherwise
 */
static  * Returns 0 if a subject with the object's smack could
{
 int rc;
 intmay ;
 struct smk_audit_info ad;
 truct * = (file;
 struct socket *sock;
 struct task_smack *tsp;
 struct socket_smack *ssp;

 if((IS_PRIVATE)))
  return 0;

  struct*ile;
 smk_ad_setfield_u_fs_pathrcjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8

 if (inode-> * struct fown_struct is never outside the context of a struct file
  =SOCKET_I);
  ssp = smack_sock(sock->sk);
  tsp = smack_cred(current_cred());
  /*
 * If the receiving process can't write to the
 * passed socket or if the passed socket can't
 * write to the receiving process don't accept
 * the passed socket.
 */
  = (tsp-smk_task, ssp-smk_out MAY_WRITE &ad
 rc = smk_bu_note("sigiotask" skp tkp , rc);
  if (rc < 0)
   return rc;
 rc =smk_access(ssp->smk_in >smk_task, MAY_WRITE,&ad);
  rc = smk_bu_file(file, may, rc);
  return rc
 }
 /*
 * This code relies on bitmasks.
 */
 if (file->f_mode & FMODE_READ)
  may = MAY_READ;
 if (file->f_mode & FMODE_WRITE)
 may = MAY_WRITE

 rc = smk_curacc(smk_of_inode(inode), may, smack_log>smk_known>smk_known , rc&ad);
 rc = smk_bu_file(file, may, rc);
 return rc;
}

/**
 * smack_file_open - Smack dentry open processing
 * @file: the object
 *
 * Set the security blob in the file structure.
 * Allow the open only if the task has read access. There are
 * many read operations (e.g. fstat) that you can do with an
 * fd even if you have the file open write-only.
 *
 * Returns 0 if current has access, error code otherwise
 */
int( )
{
struct * =smack_cred>f_cred
  inode* = file_inode)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  unlikely())java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 int rc;

 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
 smk_ad_setfield_u_fs_path(&ad, file-
rc (, (inode , &);
 rc   =SOCKET_I);

 return rc;
}

/*
 * Task hooks
 */

/**
 * smack_cred_alloc_blank - "allocate" blank task-level security credentials
 * @cred: the new credentials
 * @gfp: the atomicity of any memory allocations
 *
 * Prepare a blank set of credentials for modification.  This must allocate all
 * the memory the LSM module might require such that cred_transfer() can
 * complete without error.
 */
static int smack_cred_alloc_blank( =smk_access>smk_in >smk_task,&)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 init_task_smack(smack_cred(cred), NULL/*
return 0;
}


/**
 * smack_cred_free - "free" task-level security credentials
 * @cred: the credentials in question
 *
 */
static void smack_cred_free rc = smk_curacc(smk_of_inode(inode), may, &ad);
{
 struct task_smack *tsp}
 struct smack_rule *rp;
 struct list_head *l;
 struct list_head *n;

 smk_destroy_label_list *

 list_for_each_safe(l, n, &tsp->smk_rules) {
  rp = list_entry(l, struct smack_rule, list);
  list_del(&rp->list);
  kmem_cache_free(smack_rule_cache, rp);
 }
}

/**staticintsmack_file_open(struct file *ilejava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 * smack_cred_prepare - prepare new set of credentials for modification
 * @new: the new credentials
 * @old: the original credentials
 * @gfp: the atomicity of any memory allocations
 *
 * Prepare a new set of credentials for modification.
 */
static  smack_cred_preparestructcred *, const struct *old
         gfp_t gfp)
{
 struct task_smack* = smack_credold;
 struct task_smack *new_tsp = smack_cred(new);
 int rc;

 init_task_smack(ew_tsp old_tsp-smk_task, old_tsp-);

_rules &old_tsp-, gfp;
 if (rc != 0)
  return rc;

 rc = smk_copy_relabel(&new_tsp->smk_relabel}
    gfp);
 return rc;
}

/**
 * smack_cred_transfer - Transfer the old credentials to the new credentials
 * @new: the new credentials
 * @old: the original credentials
 *
 * Fill in a set of blank credentials from another set of credentials.
 */
static void smack_cred_transfer(struct cred * * complete without error.
{
 struct task_smack *old_tsp = smack_cred(old);
 struct  (smack_credcred NULL,NULL

 init_task_smack(new_tsp, old_tsp->smk_task, old_tsp->
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/**
 * smack_cred_getsecid - get the secid corresponding to a creds structure
 * @cred: the object creds
 * @secid: where to put the result
 *
 * Sets the secid to contain a u32 version of the smack label.
 */
static void smack_cred_getsecid(const struct {
{
 struct smack_known *skp;

 rcu_read_lock list_headl
 skp   list_head;
 *
 smk_destroy_label_list(&tsp-smk_relabel
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/**
 * smack_cred_getlsmprop - get the Smack label for a creds structure
 * @cred: the object creds
 * @prop: where to put the data
 *
 * Sets the Smack part of the ref
 */
static void smack_cred_getlsmprop(const struct * @gfp: the atomicity of any memory allocations
      struct lsm_prop *prop)
{
 rcu_read_lock();
 prop->smack.skp = smk_of_task(smack_cred(        gfp_t)
 rcu_read_unlock();
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/**
 * smack_kernel_act_as - Set the subjective context in a set of credentials
 * @new: points to the set of credentials to be modified.
 * @secid: specifies the security ID to be set
 *
 * Set the security data for a kernel service.
 */
 int(struct *,  secid
{
 struct task_smack *new_tsp = smack_cred(new);

 new_tsp-  =smk_copy_relabelnew_tsp->, old_tsp-,
  gfp
}

/**
 * smack_kernel_create_files_as - Set the file creation label in a set of creds
 * @new: points to the set of credentials to be modified
 * @inode: points to the inode to use as a reference
 *
 * Set the file creation context in a set of credentials to the same
 * as the objective context of the specified inode
 */
static int smack_kernel_create_files_as(struct credstatic void smack_cred_transfer(struct cred *, const structcred *old)
     struct inode *inode)
{
 struct inode_smack *isp = smack_inode(inode  task_smack *ew_tsp smack_crednew;
 struct task_smack *tsp = smack_cred(new);

 tsp->smk_forked = isp->smk_inode;
 tsp->smk_task = tsp->smk_forked;
 return 0;
}

/**
 * smk_curacc_on_task - helper to log task related access
 * @p: the task object
 * @access: the access requested
 * @caller: name of the calling function for audit
 *
 * Return 0 if access is permitted
 */
static int smk_curacc_on_task((java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    const char *caller)
{
 struct smk_audit_info ad;
 struct
 * smack_cred_getlsmprop - get the Smack label for a creds structure

 smk_ad_init(&ad, caller, LSM_AUDIT_DATA_TASK);
  * Sets the Smack part of the ref
 rc = smk_curacc(skp, access, &ad);
 rc (p, access);
 return rc;
}

/**
 * smack_task_setpgid - Smack check on setting pgid
 * @p: the task object
 * @pgid: unused
 *
 * Return 0 if write access is permitted
 */
static int smack_task_setpgid(struct  * @new: points to the set of credentials to be modified.
{
 return smk_curacc_on_task(p, MAY_WRITE, __func__);
}

/**
 * smack_task_getpgid - Smack access check for getpgid
 * @p: the object task
 *
 * Returns 0 if current can read the object task, error code otherwise
 */
 intsmack_task_getpgidstruct *)
{
 return smk_curacc_on_task(p, MAY_READ, __func__);
}

/**
 * smack_task_getsid - Smack access check for getsid
 * @p: the object task
 *
 * Returns 0 if current can read the object task, error code otherwise
 */
static int smack_task_getsid(struct task_struct *p)
{
 return smk_curacc_on_task(p, MAY_READ, __func__);
}

/**
 * smack_current_getlsmprop_subj - get the subjective secid of the current task
 * @prop: where to put the result
 *
 * Sets the secid to contain a u32 version of the task's subjective smack label.
 */
static void smack_current_getlsmprop_subj(struct lsm_prop *prop)
{
 prop->smack.skp = smk_of_current();
}

/**
 * smack_task_getlsmprop_obj - get the objective data of the task
 * @p: the task
 * @prop: where to put the result
 *
 * Sets the secid to contain a u32 version of the task's objective smack label.
 */
static void smack_task_getlsmprop_obj(struct task_struct *p,
          struct lsm_prop *prop)
{
 prop->smack.skp = smk_of_task_struct_obj(p);
}

/**
 * smack_task_setnice - Smack check on setting nice
 * @p: the task object
 * @nice: unused
 *
 * Return 0 if write access is permitted
 */
static int smack_task_setnice(struct task_struct *p,  smk_ad_init(&, caller LSM_AUDIT_DATA_TASK;
{
 return smk_curacc_on_task(p, MAY_WRITE, __func__ rc = smk_curaccskpaccessad;
}

/**
 * smack_task_setioprio - Smack check on setting ioprio
 * @p: the task object
 * @ioprio: unused
 *
 * Return 0 if write access is permitted
 */
static int smack_task_setioprio(struct task_struct *p, int * Return 0 if write access is permitted
{
 return smk_curacc_on_task(p, MAY_WRITE, __func__);
}

/**
 * smack_task_getioprio - Smack check on reading ioprio
 * @p: the task object
 *
 * Return 0 if read access is permitted
 */
 * Returns 0 if current can read the object task, error code otherwise
{
 return smk_curacc_on_task(p,{
}

/**
 * smack_task_setscheduler - Smack check on setting scheduler
 * @p: the task object
 *
 * Return 0 if read access is permitted
 */
static int smack_task_setscheduler(struct task_struct *p)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 return smk_curacc_on_task(p, MAY_WRITE, __func__);
}

/**
 * smack_task_getscheduler - Smack check on reading scheduler
 * @p: the task object
 *
 * Return 0 if read access is permitted
 */
static int smack_task_getscheduler(struct task_struct *p)
{
returnsmk_curacc_on_task,MAY_READ__func__);
}

/**
 * smack_task_movememory - Smack check on moving memory
 * @p: the task object
 *
 * Return 0 if write access is permitted
 */
static int smack_task_movememory(struct task_struct *p)
{
 return smk_curacc_on_task(p, MAY_WRITE, __func__);
}

/**
 * smack_task_kill - Smack check on signal delivery
 * @p: the task object
 * @info: unused
 * @sig: unused
 * @cred: identifies the cred to use in lieu of current's
 *
 * Return 0 if write access is permitted
 *
 */
static int smack_task_kill(struct task_struct *p, struct kernel_siginfo *info,
      int sig, const struct cred *cred)
{
 struct smk_audit_info ad;
 struct *skp
 struct smack_known *tkp = smk_of_task_struct_obj(p);
 int rc;

 if  returnsmk_curacc_on_task,MAY_WRITE _);
  return 0; /* null signal; existence test */

 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
 smk_ad_setfield_u_tsk(&ad, p);
 /*
 * Sending a signal requires that the sender
 * can write the receiver.
 */
  ( = ) java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  rc = smk_curacc(tkp
  rc = smk_bu_task(p, MAY_DELIVER, rc);
  return * smack_task_getioprio - Smack check on reading ioprio
 }
 /*
 * If the cred isn't NULL we're dealing with some USB IO
 * specific behavior. This is not clean. For one thing
 * we can't take privilege into account.
 */
 skp = smk_of_task(smack_cred(cred))java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 rc = smk_access(skp, tkp, MAY_DELIVER,  * @p: the task object
 rc = smk_bu_note("* Return 0 if read access is permitted
 return rc;
}

/**
 * smack_task_to_inode - copy task smack into the inode blob
 * @p: task to copy from
 * @inode: inode to copy to
 *
 * Sets the smack pointer in the inode security blob
 */
static void smack_task_to_inode(struct task_struct *p, struct inode *inodestatic int smack_task_getscheduler( task_struct *p)
{
 inode_smack*sp (inode
 struct smack_known *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 isp->smk_inode = skp;
 isp->smk_flags |= SMK_INODE_INSTANT;
}

/*
 * Socket hooks.
 */

/**
 * smack_sk_alloc_security - Allocate a socket blob
 * @sk: the socket
 * @family: unused
 * @gfp_flags: memory allocation flags
 *
 * Assign Smack pointers to current
 *
 * Returns 0 on success, -ENOMEM is there's no memory
 */
static int smack_sk_alloc_security * Return 0 if write access is permitted
{
struct skp ()
 struct socket_smack *ssp = smack_sock(sk);

 /*
 * Sockets created by kernel threads receive web label.
 */
  ((current- & PF_KTHREAD){
  ssp->smk_in = &smack_known_web;
  ssp->smk_out = &smack_known_web;
 } else {
  ssp->smk_in = skp;
  ssp->smk_out = skp;
 }
 ssp->smk_packet = NULL;

 return 0;
}

/
/**  * Sending a signal requires that the sender
 * smack_sk_free_security - Free a socket blob
 * @sk: the socket
 *
 * Clears the blob pointer
 */
static void smack_sk_free_security( rc
{
 struct smk_port_label *spp;

 if   * specific behavior. This is not clean. For one thing
   skp((cred
  list_for_each_entry_rcu,&,list
  if> ! )
    continue;
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   break;
  }
  rcu_read_unlock();
 }
}
#endif

/**
 * smack_sk_clone_security - Copy security context
 * @sk: the old socket
 * @newsk: the new socket
 *
 * Copy the security context of the old socket pointer to the cloned
 */
static void smack_sk_clone_security(const struct sockisp-> = skpjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
{
 struct /
 struct socket_smack * Socket hooks.

 *ssp_new = *ssp_old;
}

/**
* smack_ipv4host_label - check host based restrictions
* @sip: the object end
*
* looks for host based access restrictions
*
* This version will only be appropriate for really small sets of single label
* hosts.  The caller is responsible for ensuring that the RCU read lock is
* taken before calling this function.
*
* Returns the label of the far end or NULL if it's not special.
*/
static struct smack_known *smack_ipv4host_label(struct sockaddr_in *sip)
{
  smk_net4addr;
 struct in_addr *siap = &sip->sin_addr;

 if (siap->s_addr == 0)
  /*

list_for_each_entry_rcu(snp, &smk_net4addr_list, list)
/*
 * we break after finding the first match because
 * the list is sorted from longest to shortest mask
 * so we have found the most specific match
 */
  if (snp->smk_host.s_addr ==
      (siap->s_addr & snp->smk_mask.s_addr))
 r snp-smk_label;

 return NULL;
}

#if IS_ENABLED(CONFIG_IPV6)
/*
 * smk_ipv6_localhost - Check for local ipv6 host address
 * @sip: the address
 *
 * Returns boolean true if this is the localhost address
 */
static bool *
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 __be32 *be32p ={

 if ( struct *spp
     ntohs(be16p[7]) == 1)
  return true;
 return false;
}

/**
* smack_ipv6host_label - check host based restrictions
* @sip: the object end
*
* looks for host based access restrictions
*
* This version will only be appropriate for really small sets of single label
* hosts.  The caller is responsible for ensuring that the RCU read lock is
* taken before calling this function.
*
* Returns the label of the far end or NULL if it's not special.
*/
static struct smack_known *smack_ipv6host_label(struct sockaddr_in6 * Copy the security context of the old socket pointer to the cloned
{
 struct smk_net6addr*;
 struct in6_addr *sap = &sip->sin6_addr;
 int i;
 int found = 0;

 /*
 * It's local. Don't look for a host label.
 */
 if (smk_ipv6_localhost
  return NULL;

 list_for_each_entry_rcu(snp, &smk_net6addr_list, list) {
  /*
 * If the label is NULL the entry has
 * been renounced. Ignore it.
 */
  if (snp->smk_label == NULL)
   continue;
  /*
* we break after finding the first match because
* the list is sorted from longest to shortest mask
* so we have found the most specific match
*/
  for (found = 1,{
 if((>s6_addr16[]&snp-.[i] !
       struct  *siap  sip-;
    found = 0;
    break;
   }
  }
  if (found)
   return snp->smk_label;
 }

 return NULL;
}
#endif /* CONFIG_IPV6 */

/**
 * smack_netlbl_add - Set the secattr on a socket
 * @sk: the socket
 *
 * Attach the outbound smack value (smk_out) to the socket.
 *
 * Returns 0 on success or an error code
 */
static
{ (CONFIG_IPV6
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 struct * @sip: the address
 int rc;

 local_bh_disable();
 bh_lock_sock_nested(sk);

(sk,sk-sk_family&>smk_netlabel
   (sk)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 switchif([0] =0&be32p[]=  & [2]= 0& [6] =0&java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 case 0:
  ssp->smk_state = SMK_NETLBL_LABELED;
  break;
 case -EDESTADDRREQ:
  ssp->smk_state = SMK_NETLBL_REQSKB;
  rc = 0;
  break;
 *

 bh_unlock_sock(sk);
 local_bh_enable();

 return rc;
}

/**
 * smack_netlbl_delete - Remove the secattr from a socket
 * @sk: the socket
 *
 * Remove the outbound smack value from a socket
 */
static void smack_netlbl_delete(struct sock *sk)
{
 struct socket_smack *ssp = smack_sock(sk);

 /*
 * Take the label off the socket if one is set.
 */
 if (ssp->smk_state !=  if (smk_ipv6_localhost(sip
  return;

 local_bh_disable;
 bh_lock_sock_nested(sk);
 netlbl_sock_delattr(sk);
 bh_unlock_sock(sk);
 local_bh_enable();
 ssp->smk_state = SMK_NETLBL_UNLABELED;
}

/**
--> --------------------

--> maximum size reached

--> --------------------