security/smack/smack_lsm.c

   1 /*
   2  *  Simplified MAC Kernel (smack) security module
   3  *
   4  *  This file contains the smack hook function implementations.
   5  *
   6  *  Authors:
   7  *      Casey Schaufler <casey@schaufler-ca.com>
   8  *      Jarkko Sakkinen <jarkko.sakkinen@intel.com>
   9  *
  10  *  Copyright (C) 2007 Casey Schaufler <casey@schaufler-ca.com>
  11  *  Copyright (C) 2009 Hewlett-Packard Development Company, L.P.
  12  *                Paul Moore <paul@paul-moore.com>
  13  *  Copyright (C) 2010 Nokia Corporation
  14  *  Copyright (C) 2011 Intel Corporation.
  15  *
  16  *      This program is free software; you can redistribute it and/or modify
  17  *      it under the terms of the GNU General Public License version 2,
  18  *      as published by the Free Software Foundation.
  19  */
  20
  21 #include <linux/xattr.h>
  22 #include <linux/pagemap.h>
  23 #include <linux/mount.h>
  24 #include <linux/stat.h>
  25 #include <linux/kd.h>
  26 #include <asm/ioctls.h>
  27 #include <linux/ip.h>
  28 #include <linux/tcp.h>
  29 #include <linux/udp.h>
  30 #include <linux/slab.h>
  31 #include <linux/mutex.h>
  32 #include <linux/pipe_fs_i.h>
  33 #include <net/netlabel.h>
  34 #include <net/cipso_ipv4.h>
  35 #include <linux/audit.h>
  36 #include <linux/magic.h>
  37 #include <linux/dcache.h>
  38 #include <linux/personality.h>
  39 #include <linux/msg.h>
  40 #include <linux/shm.h>
  41 #include <linux/binfmts.h>
  42 #include "smack.h"
  43
  44 #define task_security(task)     (task_cred_xxx((task), security))
  45
  46 #define TRANS_TRUE      "TRUE"
  47 #define TRANS_TRUE_SIZE 4
  48
  49 /**
  50  * smk_fetch - Fetch the smack label from a file.
  51  * @ip: a pointer to the inode
  52  * @dp: a pointer to the dentry
  53  *
  54  * Returns a pointer to the master list entry for the Smack label
  55  * or NULL if there was no label to fetch.
  56  */
  57 static char *smk_fetch(const char *name, struct inode *ip, struct dentry *dp)
  58 {
  59         int rc;
  60         char in[SMK_LABELLEN];
  61
  62         if (ip->i_op->getxattr == NULL)
  63                 return NULL;
  64
  65         rc = ip->i_op->getxattr(dp, name, in, SMK_LABELLEN);
  66         if (rc < 0)
  67                 return NULL;
  68
  69         return smk_import(in, rc);
  70 }
  71
  72 /**
  73  * new_inode_smack - allocate an inode security blob
  74  * @smack: a pointer to the Smack label to use in the blob
  75  *
  76  * Returns the new blob or NULL if there's no memory available
  77  */
  78 struct inode_smack *new_inode_smack(char *smack)
  79 {
  80         struct inode_smack *isp;
  81
  82         isp = kzalloc(sizeof(struct inode_smack), GFP_KERNEL);
  83         if (isp == NULL)
  84                 return NULL;
  85
  86         isp->smk_inode = smack;
  87         isp->smk_flags = 0;
  88         mutex_init(&isp->smk_lock);
  89
  90         return isp;
  91 }
  92
  93 /**
  94  * new_task_smack - allocate a task security blob
  95  * @smack: a pointer to the Smack label to use in the blob
  96  *
  97  * Returns the new blob or NULL if there's no memory available
  98  */
  99 static struct task_smack *new_task_smack(char *task, char *forked, gfp_t gfp)
 100 {
 101         struct task_smack *tsp;
 102
 103         tsp = kzalloc(sizeof(struct task_smack), gfp);
 104         if (tsp == NULL)
 105                 return NULL;
 106
 107         tsp->smk_task = task;
 108         tsp->smk_forked = forked;
 109         INIT_LIST_HEAD(&tsp->smk_rules);
 110         mutex_init(&tsp->smk_rules_lock);
 111
 112         return tsp;
 113 }
 114
 115 /**
 116  * smk_copy_rules - copy a rule set
 117  * @nhead - new rules header pointer
 118  * @ohead - old rules header pointer
 119  *
 120  * Returns 0 on success, -ENOMEM on error
 121  */
 122 static int smk_copy_rules(struct list_head *nhead, struct list_head *ohead,
 123                                 gfp_t gfp)
 124 {
 125         struct smack_rule *nrp;
 126         struct smack_rule *orp;
 127         int rc = 0;
 128
 129         INIT_LIST_HEAD(nhead);
 130
 131         list_for_each_entry_rcu(orp, ohead, list) {
 132                 nrp = kzalloc(sizeof(struct smack_rule), gfp);
 133                 if (nrp == NULL) {
 134                         rc = -ENOMEM;
 135                         break;
 136                 }
 137                 *nrp = *orp;
 138                 list_add_rcu(&nrp->list, nhead);
 139         }
 140         return rc;
 141 }
 142
 143 /*
 144  * LSM hooks.
 145  * We he, that is fun!
 146  */
 147
 148 /**
 149  * smack_ptrace_access_check - Smack approval on PTRACE_ATTACH
 150  * @ctp: child task pointer
 151  * @mode: ptrace attachment mode
 152  *
 153  * Returns 0 if access is OK, an error code otherwise
 154  *
 155  * Do the capability checks, and require read and write.
 156  */
 157 static int smack_ptrace_access_check(struct task_struct *ctp, unsigned int mode)
 158 {
 159         int rc;
 160         struct smk_audit_info ad;
 161         char *tsp;
 162
 163         rc = cap_ptrace_access_check(ctp, mode);
 164         if (rc != 0)
 165                 return rc;
 166
 167         tsp = smk_of_task(task_security(ctp));
 168         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
 169         smk_ad_setfield_u_tsk(&ad, ctp);
 170
 171         rc = smk_curacc(tsp, MAY_READWRITE, &ad);
 172         return rc;
 173 }
 174
 175 /**
 176  * smack_ptrace_traceme - Smack approval on PTRACE_TRACEME
 177  * @ptp: parent task pointer
 178  *
 179  * Returns 0 if access is OK, an error code otherwise
 180  *
 181  * Do the capability checks, and require read and write.
 182  */
 183 static int smack_ptrace_traceme(struct task_struct *ptp)
 184 {
 185         int rc;
 186         struct smk_audit_info ad;
 187         char *tsp;
 188
 189         rc = cap_ptrace_traceme(ptp);
 190         if (rc != 0)
 191                 return rc;
 192
 193         tsp = smk_of_task(task_security(ptp));
 194         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
 195         smk_ad_setfield_u_tsk(&ad, ptp);
 196
 197         rc = smk_curacc(tsp, MAY_READWRITE, &ad);
 198         return rc;
 199 }
 200
 201 /**
 202  * smack_syslog - Smack approval on syslog
 203  * @type: message type
 204  *
 205  * Require that the task has the floor label
 206  *
 207  * Returns 0 on success, error code otherwise.
 208  */
 209 static int smack_syslog(int typefrom_file)
 210 {
 211         int rc = 0;
 212         char *sp = smk_of_current();
 213
 214         if (capable(CAP_MAC_OVERRIDE))
 215                 return 0;
 216
 217          if (sp != smack_known_floor.smk_known)
 218                 rc = -EACCES;
 219
 220         return rc;
 221 }
 222
 223
 224 /*
 225  * Superblock Hooks.
 226  */
 227
 228 /**
 229  * smack_sb_alloc_security - allocate a superblock blob
 230  * @sb: the superblock getting the blob
 231  *
 232  * Returns 0 on success or -ENOMEM on error.
 233  */
 234 static int smack_sb_alloc_security(struct super_block *sb)
 235 {
 236         struct superblock_smack *sbsp;
 237
 238         sbsp = kzalloc(sizeof(struct superblock_smack), GFP_KERNEL);
 239
 240         if (sbsp == NULL)
 241                 return -ENOMEM;
 242
 243         sbsp->smk_root = smack_known_floor.smk_known;
 244         sbsp->smk_default = smack_known_floor.smk_known;
 245         sbsp->smk_floor = smack_known_floor.smk_known;
 246         sbsp->smk_hat = smack_known_hat.smk_known;
 247         sbsp->smk_initialized = 0;
 248         spin_lock_init(&sbsp->smk_sblock);
 249
 250         sb->s_security = sbsp;
 251
 252         return 0;
 253 }
 254
 255 /**
 256  * smack_sb_free_security - free a superblock blob
 257  * @sb: the superblock getting the blob
 258  *
 259  */
 260 static void smack_sb_free_security(struct super_block *sb)
 261 {
 262         kfree(sb->s_security);
 263         sb->s_security = NULL;
 264 }
 265
 266 /**
 267  * smack_sb_copy_data - copy mount options data for processing
 268  * @orig: where to start
 269  * @smackopts: mount options string
 270  *
 271  * Returns 0 on success or -ENOMEM on error.
 272  *
 273  * Copy the Smack specific mount options out of the mount
 274  * options list.
 275  */
 276 static int smack_sb_copy_data(char *orig, char *smackopts)
 277 {
 278         char *cp, *commap, *otheropts, *dp;
 279
 280         otheropts = (char *)get_zeroed_page(GFP_KERNEL);
 281         if (otheropts == NULL)
 282                 return -ENOMEM;
 283
 284         for (cp = orig, commap = orig; commap != NULL; cp = commap + 1) {
 285                 if (strstr(cp, SMK_FSDEFAULT) == cp)
 286                         dp = smackopts;
 287                 else if (strstr(cp, SMK_FSFLOOR) == cp)
 288                         dp = smackopts;
 289                 else if (strstr(cp, SMK_FSHAT) == cp)
 290                         dp = smackopts;
 291                 else if (strstr(cp, SMK_FSROOT) == cp)
 292                         dp = smackopts;
 293                 else
 294                         dp = otheropts;
 295
 296                 commap = strchr(cp, ',');
 297                 if (commap != NULL)
 298                         *commap = '\0';
 299
 300                 if (*dp != '\0')
 301                         strcat(dp, ",");
 302                 strcat(dp, cp);
 303         }
 304
 305         strcpy(orig, otheropts);
 306         free_page((unsigned long)otheropts);
 307
 308         return 0;
 309 }
 310
 311 /**
 312  * smack_sb_kern_mount - Smack specific mount processing
 313  * @sb: the file system superblock
 314  * @flags: the mount flags
 315  * @data: the smack mount options
 316  *
 317  * Returns 0 on success, an error code on failure
 318  */
 319 static int smack_sb_kern_mount(struct super_block *sb, int flags, void *data)
 320 {
 321         struct dentry *root = sb->s_root;
 322         struct inode *inode = root->d_inode;
 323         struct superblock_smack *sp = sb->s_security;
 324         struct inode_smack *isp;
 325         char *op;
 326         char *commap;
 327         char *nsp;
 328
 329         spin_lock(&sp->smk_sblock);
 330         if (sp->smk_initialized != 0) {
 331                 spin_unlock(&sp->smk_sblock);
 332                 return 0;
 333         }
 334         sp->smk_initialized = 1;
 335         spin_unlock(&sp->smk_sblock);
 336
 337         for (op = data; op != NULL; op = commap) {
 338                 commap = strchr(op, ',');
 339                 if (commap != NULL)
 340                         *commap++ = '\0';
 341
 342                 if (strncmp(op, SMK_FSHAT, strlen(SMK_FSHAT)) == 0) {
 343                         op += strlen(SMK_FSHAT);
 344                         nsp = smk_import(op, 0);
 345                         if (nsp != NULL)
 346                                 sp->smk_hat = nsp;
 347                 } else if (strncmp(op, SMK_FSFLOOR, strlen(SMK_FSFLOOR)) == 0) {
 348                         op += strlen(SMK_FSFLOOR);
 349                         nsp = smk_import(op, 0);
 350                         if (nsp != NULL)
 351                                 sp->smk_floor = nsp;
 352                 } else if (strncmp(op, SMK_FSDEFAULT,
 353                                    strlen(SMK_FSDEFAULT)) == 0) {
 354                         op += strlen(SMK_FSDEFAULT);
 355                         nsp = smk_import(op, 0);
 356                         if (nsp != NULL)
 357                                 sp->smk_default = nsp;
 358                 } else if (strncmp(op, SMK_FSROOT, strlen(SMK_FSROOT)) == 0) {
 359                         op += strlen(SMK_FSROOT);
 360                         nsp = smk_import(op, 0);
 361                         if (nsp != NULL)
 362                                 sp->smk_root = nsp;
 363                 }
 364         }
 365
 366         /*
 367          * Initialize the root inode.
 368          */
 369         isp = inode->i_security;
 370         if (isp == NULL)
 371                 inode->i_security = new_inode_smack(sp->smk_root);
 372         else
 373                 isp->smk_inode = sp->smk_root;
 374
 375         return 0;
 376 }
 377
 378 /**
 379  * smack_sb_statfs - Smack check on statfs
 380  * @dentry: identifies the file system in question
 381  *
 382  * Returns 0 if current can read the floor of the filesystem,
 383  * and error code otherwise
 384  */
 385 static int smack_sb_statfs(struct dentry *dentry)
 386 {
 387         struct superblock_smack *sbp = dentry->d_sb->s_security;
 388         int rc;
 389         struct smk_audit_info ad;
 390
 391         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
 392         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
 393
 394         rc = smk_curacc(sbp->smk_floor, MAY_READ, &ad);
 395         return rc;
 396 }
 397
 398 /**
 399  * smack_sb_mount - Smack check for mounting
 400  * @dev_name: unused
 401  * @path: mount point
 402  * @type: unused
 403  * @flags: unused
 404  * @data: unused
 405  *
 406  * Returns 0 if current can write the floor of the filesystem
 407  * being mounted on, an error code otherwise.
 408  */
 409 static int smack_sb_mount(char *dev_name, struct path *path,
 410                           char *type, unsigned long flags, void *data)
 411 {
 412         struct superblock_smack *sbp = path->dentry->d_sb->s_security;
 413         struct smk_audit_info ad;
 414
 415         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
 416         smk_ad_setfield_u_fs_path(&ad, *path);
 417
 418         return smk_curacc(sbp->smk_floor, MAY_WRITE, &ad);
 419 }
 420
 421 /**
 422  * smack_sb_umount - Smack check for unmounting
 423  * @mnt: file system to unmount
 424  * @flags: unused
 425  *
 426  * Returns 0 if current can write the floor of the filesystem
 427  * being unmounted, an error code otherwise.
 428  */
 429 static int smack_sb_umount(struct vfsmount *mnt, int flags)
 430 {
 431         struct superblock_smack *sbp;
 432         struct smk_audit_info ad;
 433         struct path path;
 434
 435         path.dentry = mnt->mnt_root;
 436         path.mnt = mnt;
 437
 438         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
 439         smk_ad_setfield_u_fs_path(&ad, path);
 440
 441         sbp = path.dentry->d_sb->s_security;
 442         return smk_curacc(sbp->smk_floor, MAY_WRITE, &ad);
 443 }
 444
 445 /*
 446  * BPRM hooks
 447  */
 448
 449 /**
 450  * smack_bprm_set_creds - set creds for exec
 451  * @bprm: the exec information
 452  *
 453  * Returns 0 if it gets a blob, -ENOMEM otherwise
 454  */
 455 static int smack_bprm_set_creds(struct linux_binprm *bprm)
 456 {
 457         struct inode *inode = bprm->file->f_path.dentry->d_inode;
 458         struct task_smack *bsp = bprm->cred->security;
 459         struct inode_smack *isp;
 460         int rc;
 461
 462         rc = cap_bprm_set_creds(bprm);
 463         if (rc != 0)
 464                 return rc;
 465
 466         if (bprm->cred_prepared)
 467                 return 0;
 468
 469         isp = inode->i_security;
 470         if (isp->smk_task == NULL || isp->smk_task == bsp->smk_task)
 471                 return 0;
 472
 473         if (bprm->unsafe)
 474                 return -EPERM;
 475
 476         bsp->smk_task = isp->smk_task;
 477         bprm->per_clear |= PER_CLEAR_ON_SETID;
 478
 479         return 0;
 480 }
 481
 482 /**
 483  * smack_bprm_committing_creds - Prepare to install the new credentials
 484  * from bprm.
 485  *
 486  * @bprm: binprm for exec
 487  */
 488 static void smack_bprm_committing_creds(struct linux_binprm *bprm)
 489 {
 490         struct task_smack *bsp = bprm->cred->security;
 491
 492         if (bsp->smk_task != bsp->smk_forked)
 493                 current->pdeath_signal = 0;
 494 }
 495
 496 /**
 497  * smack_bprm_secureexec - Return the decision to use secureexec.
 498  * @bprm: binprm for exec
 499  *
 500  * Returns 0 on success.
 501  */
 502 static int smack_bprm_secureexec(struct linux_binprm *bprm)
 503 {
 504         struct task_smack *tsp = current_security();
 505         int ret = cap_bprm_secureexec(bprm);
 506
 507         if (!ret && (tsp->smk_task != tsp->smk_forked))
 508                 ret = 1;
 509
 510         return ret;
 511 }
 512
 513 /*
 514  * Inode hooks
 515  */
 516
 517 /**
 518  * smack_inode_alloc_security - allocate an inode blob
 519  * @inode: the inode in need of a blob
 520  *
 521  * Returns 0 if it gets a blob, -ENOMEM otherwise
 522  */
 523 static int smack_inode_alloc_security(struct inode *inode)
 524 {
 525         inode->i_security = new_inode_smack(smk_of_current());
 526         if (inode->i_security == NULL)
 527                 return -ENOMEM;
 528         return 0;
 529 }
 530
 531 /**
 532  * smack_inode_free_security - free an inode blob
 533  * @inode: the inode with a blob
 534  *
 535  * Clears the blob pointer in inode
 536  */
 537 static void smack_inode_free_security(struct inode *inode)
 538 {
 539         kfree(inode->i_security);
 540         inode->i_security = NULL;
 541 }
 542
 543 /**
 544  * smack_inode_init_security - copy out the smack from an inode
 545  * @inode: the inode
 546  * @dir: unused
 547  * @qstr: unused
 548  * @name: where to put the attribute name
 549  * @value: where to put the attribute value
 550  * @len: where to put the length of the attribute
 551  *
 552  * Returns 0 if it all works out, -ENOMEM if there's no memory
 553  */
 554 static int smack_inode_init_security(struct inode *inode, struct inode *dir,
 555                                      const struct qstr *qstr, char **name,
 556                                      void **value, size_t *len)
 557 {
 558         struct smack_known *skp;
 559         char *csp = smk_of_current();
 560         char *isp = smk_of_inode(inode);
 561         char *dsp = smk_of_inode(dir);
 562         int may;
 563
 564         if (name) {
 565                 *name = kstrdup(XATTR_SMACK_SUFFIX, GFP_KERNEL);
 566                 if (*name == NULL)
 567                         return -ENOMEM;
 568         }
 569
 570         if (value) {
 571                 skp = smk_find_entry(csp);
 572                 rcu_read_lock();
 573                 may = smk_access_entry(csp, dsp, &skp->smk_rules);
 574                 rcu_read_unlock();
 575
 576                 /*
 577                  * If the access rule allows transmutation and
 578                  * the directory requests transmutation then
 579                  * by all means transmute.
 580                  */
 581                 if (may > 0 && ((may & MAY_TRANSMUTE) != 0) &&
 582                     smk_inode_transmutable(dir))
 583                         isp = dsp;
 584
 585                 *value = kstrdup(isp, GFP_KERNEL);
 586                 if (*value == NULL)
 587                         return -ENOMEM;
 588         }
 589
 590         if (len)
 591                 *len = strlen(isp) + 1;
 592
 593         return 0;
 594 }
 595
 596 /**
 597  * smack_inode_link - Smack check on link
 598  * @old_dentry: the existing object
 599  * @dir: unused
 600  * @new_dentry: the new object
 601  *
 602  * Returns 0 if access is permitted, an error code otherwise
 603  */
 604 static int smack_inode_link(struct dentry *old_dentry, struct inode *dir,
 605                             struct dentry *new_dentry)
 606 {
 607         char *isp;
 608         struct smk_audit_info ad;
 609         int rc;
 610
 611         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
 612         smk_ad_setfield_u_fs_path_dentry(&ad, old_dentry);
 613
 614         isp = smk_of_inode(old_dentry->d_inode);
 615         rc = smk_curacc(isp, MAY_WRITE, &ad);
 616
 617         if (rc == 0 && new_dentry->d_inode != NULL) {
 618                 isp = smk_of_inode(new_dentry->d_inode);
 619                 smk_ad_setfield_u_fs_path_dentry(&ad, new_dentry);
 620                 rc = smk_curacc(isp, MAY_WRITE, &ad);
 621         }
 622
 623         return rc;
 624 }
 625
 626 /**
 627  * smack_inode_unlink - Smack check on inode deletion
 628  * @dir: containing directory object
 629  * @dentry: file to unlink
 630  *
 631  * Returns 0 if current can write the containing directory
 632  * and the object, error code otherwise
 633  */
 634 static int smack_inode_unlink(struct inode *dir, struct dentry *dentry)
 635 {
 636         struct inode *ip = dentry->d_inode;
 637         struct smk_audit_info ad;
 638         int rc;
 639
 640         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
 641         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
 642
 643         /*
 644          * You need write access to the thing you're unlinking
 645          */
 646         rc = smk_curacc(smk_of_inode(ip), MAY_WRITE, &ad);
 647         if (rc == 0) {
 648                 /*
 649                  * You also need write access to the containing directory
 650                  */
 651                 smk_ad_setfield_u_fs_path_dentry(&ad, NULL);
 652                 smk_ad_setfield_u_fs_inode(&ad, dir);
 653                 rc = smk_curacc(smk_of_inode(dir), MAY_WRITE, &ad);
 654         }
 655         return rc;
 656 }
 657
 658 /**
 659  * smack_inode_rmdir - Smack check on directory deletion
 660  * @dir: containing directory object
 661  * @dentry: directory to unlink
 662  *
 663  * Returns 0 if current can write the containing directory
 664  * and the directory, error code otherwise
 665  */
 666 static int smack_inode_rmdir(struct inode *dir, struct dentry *dentry)
 667 {
 668         struct smk_audit_info ad;
 669         int rc;
 670
 671         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
 672         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
 673
 674         /*
 675          * You need write access to the thing you're removing
 676          */
 677         rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
 678         if (rc == 0) {
 679                 /*
 680                  * You also need write access to the containing directory
 681                  */
 682                 smk_ad_setfield_u_fs_path_dentry(&ad, NULL);
 683                 smk_ad_setfield_u_fs_inode(&ad, dir);
 684                 rc = smk_curacc(smk_of_inode(dir), MAY_WRITE, &ad);
 685         }
 686
 687         return rc;
 688 }
 689
 690 /**
 691  * smack_inode_rename - Smack check on rename
 692  * @old_inode: the old directory
 693  * @old_dentry: unused
 694  * @new_inode: the new directory
 695  * @new_dentry: unused
 696  *
 697  * Read and write access is required on both the old and
 698  * new directories.
 699  *
 700  * Returns 0 if access is permitted, an error code otherwise
 701  */
 702 static int smack_inode_rename(struct inode *old_inode,
 703                               struct dentry *old_dentry,
 704                               struct inode *new_inode,
 705                               struct dentry *new_dentry)
 706 {
 707         int rc;
 708         char *isp;
 709         struct smk_audit_info ad;
 710
 711         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
 712         smk_ad_setfield_u_fs_path_dentry(&ad, old_dentry);
 713
 714         isp = smk_of_inode(old_dentry->d_inode);
 715         rc = smk_curacc(isp, MAY_READWRITE, &ad);
 716
 717         if (rc == 0 && new_dentry->d_inode != NULL) {
 718                 isp = smk_of_inode(new_dentry->d_inode);
 719                 smk_ad_setfield_u_fs_path_dentry(&ad, new_dentry);
 720                 rc = smk_curacc(isp, MAY_READWRITE, &ad);
 721         }
 722         return rc;
 723 }
 724
 725 /**
 726  * smack_inode_permission - Smack version of permission()
 727  * @inode: the inode in question
 728  * @mask: the access requested
 729  *
 730  * This is the important Smack hook.
 731  *
 732  * Returns 0 if access is permitted, -EACCES otherwise
 733  */
 734 static int smack_inode_permission(struct inode *inode, int mask)
 735 {
 736         struct smk_audit_info ad;
 737         int no_block = mask & MAY_NOT_BLOCK;
 738
 739         mask &= (MAY_READ|MAY_WRITE|MAY_EXEC|MAY_APPEND);
 740         /*
 741          * No permission to check. Existence test. Yup, it's there.
 742          */
 743         if (mask == 0)
 744                 return 0;
 745
 746         /* May be droppable after audit */
 747         if (no_block)
 748                 return -ECHILD;
 749         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_INODE);
 750         smk_ad_setfield_u_fs_inode(&ad, inode);
 751         return smk_curacc(smk_of_inode(inode), mask, &ad);
 752 }
 753
 754 /**
 755  * smack_inode_setattr - Smack check for setting attributes
 756  * @dentry: the object
 757  * @iattr: for the force flag
 758  *
 759  * Returns 0 if access is permitted, an error code otherwise
 760  */
 761 static int smack_inode_setattr(struct dentry *dentry, struct iattr *iattr)
 762 {
 763         struct smk_audit_info ad;
 764         /*
 765          * Need to allow for clearing the setuid bit.
 766          */
 767         if (iattr->ia_valid & ATTR_FORCE)
 768                 return 0;
 769         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
 770         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
 771
 772         return smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
 773 }
 774
 775 /**
 776  * smack_inode_getattr - Smack check for getting attributes
 777  * @mnt: unused
 778  * @dentry: the object
 779  *
 780  * Returns 0 if access is permitted, an error code otherwise
 781  */
 782 static int smack_inode_getattr(struct vfsmount *mnt, struct dentry *dentry)
 783 {
 784         struct smk_audit_info ad;
 785         struct path path;
 786
 787         path.dentry = dentry;
 788         path.mnt = mnt;
 789
 790         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
 791         smk_ad_setfield_u_fs_path(&ad, path);
 792         return smk_curacc(smk_of_inode(dentry->d_inode), MAY_READ, &ad);
 793 }
 794
 795 /**
 796  * smack_inode_setxattr - Smack check for setting xattrs
 797  * @dentry: the object
 798  * @name: name of the attribute
 799  * @value: unused
 800  * @size: unused
 801  * @flags: unused
 802  *
 803  * This protects the Smack attribute explicitly.
 804  *
 805  * Returns 0 if access is permitted, an error code otherwise
 806  */
 807 static int smack_inode_setxattr(struct dentry *dentry, const char *name,
 808                                 const void *value, size_t size, int flags)
 809 {
 810         struct smk_audit_info ad;
 811         int rc = 0;
 812
 813         if (strcmp(name, XATTR_NAME_SMACK) == 0 ||
 814             strcmp(name, XATTR_NAME_SMACKIPIN) == 0 ||
 815             strcmp(name, XATTR_NAME_SMACKIPOUT) == 0 ||
 816             strcmp(name, XATTR_NAME_SMACKEXEC) == 0 ||
 817             strcmp(name, XATTR_NAME_SMACKMMAP) == 0) {
 818                 if (!capable(CAP_MAC_ADMIN))
 819                         rc = -EPERM;
 820                 /*
 821                  * check label validity here so import wont fail on
 822                  * post_setxattr
 823                  */
 824                 if (size == 0 || size >= SMK_LABELLEN ||
 825                     smk_import(value, size) == NULL)
 826                         rc = -EINVAL;
 827         } else if (strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0) {
 828                 if (!capable(CAP_MAC_ADMIN))
 829                         rc = -EPERM;
 830                 if (size != TRANS_TRUE_SIZE ||
 831                     strncmp(value, TRANS_TRUE, TRANS_TRUE_SIZE) != 0)
 832                         rc = -EINVAL;
 833         } else
 834                 rc = cap_inode_setxattr(dentry, name, value, size, flags);
 835
 836         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
 837         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
 838
 839         if (rc == 0)
 840                 rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
 841
 842         return rc;
 843 }
 844
 845 /**
 846  * smack_inode_post_setxattr - Apply the Smack update approved above
 847  * @dentry: object
 848  * @name: attribute name
 849  * @value: attribute value
 850  * @size: attribute size
 851  * @flags: unused
 852  *
 853  * Set the pointer in the inode blob to the entry found
 854  * in the master label list.
 855  */
 856 static void smack_inode_post_setxattr(struct dentry *dentry, const char *name,
 857                                       const void *value, size_t size, int flags)
 858 {
 859         char *nsp;
 860         struct inode_smack *isp = dentry->d_inode->i_security;
 861
 862         if (strcmp(name, XATTR_NAME_SMACK) == 0) {
 863                 nsp = smk_import(value, size);
 864                 if (nsp != NULL)
 865                         isp->smk_inode = nsp;
 866                 else
 867                         isp->smk_inode = smack_known_invalid.smk_known;
 868         } else if (strcmp(name, XATTR_NAME_SMACKEXEC) == 0) {
 869                 nsp = smk_import(value, size);
 870                 if (nsp != NULL)
 871                         isp->smk_task = nsp;
 872                 else
 873                         isp->smk_task = smack_known_invalid.smk_known;
 874         } else if (strcmp(name, XATTR_NAME_SMACKMMAP) == 0) {
 875                 nsp = smk_import(value, size);
 876                 if (nsp != NULL)
 877                         isp->smk_mmap = nsp;
 878                 else
 879                         isp->smk_mmap = smack_known_invalid.smk_known;
 880         } else if (strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0)
 881                 isp->smk_flags |= SMK_INODE_TRANSMUTE;
 882
 883         return;
 884 }
 885
 886 /**
 887  * smack_inode_getxattr - Smack check on getxattr
 888  * @dentry: the object
 889  * @name: unused
 890  *
 891  * Returns 0 if access is permitted, an error code otherwise
 892  */
 893 static int smack_inode_getxattr(struct dentry *dentry, const char *name)
 894 {
 895         struct smk_audit_info ad;
 896
 897         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
 898         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
 899
 900         return smk_curacc(smk_of_inode(dentry->d_inode), MAY_READ, &ad);
 901 }
 902
 903 /**
 904  * smack_inode_removexattr - Smack check on removexattr
 905  * @dentry: the object
 906  * @name: name of the attribute
 907  *
 908  * Removing the Smack attribute requires CAP_MAC_ADMIN
 909  *
 910  * Returns 0 if access is permitted, an error code otherwise
 911  */
 912 static int smack_inode_removexattr(struct dentry *dentry, const char *name)
 913 {
 914         struct inode_smack *isp;
 915         struct smk_audit_info ad;
 916         int rc = 0;
 917
 918         if (strcmp(name, XATTR_NAME_SMACK) == 0 ||
 919             strcmp(name, XATTR_NAME_SMACKIPIN) == 0 ||
 920             strcmp(name, XATTR_NAME_SMACKIPOUT) == 0 ||
 921             strcmp(name, XATTR_NAME_SMACKEXEC) == 0 ||
 922             strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0 ||
 923             strcmp(name, XATTR_NAME_SMACKMMAP)) {
 924                 if (!capable(CAP_MAC_ADMIN))
 925                         rc = -EPERM;
 926         } else
 927                 rc = cap_inode_removexattr(dentry, name);
 928
 929         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
 930         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
 931         if (rc == 0)
 932                 rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
 933
 934         if (rc == 0) {
 935                 isp = dentry->d_inode->i_security;
 936                 isp->smk_task = NULL;
 937                 isp->smk_mmap = NULL;
 938         }
 939
 940         return rc;
 941 }
 942
 943 /**
 944  * smack_inode_getsecurity - get smack xattrs
 945  * @inode: the object
 946  * @name: attribute name
 947  * @buffer: where to put the result
 948  * @alloc: unused
 949  *
 950  * Returns the size of the attribute or an error code
 951  */
 952 static int smack_inode_getsecurity(const struct inode *inode,
 953                                    const char *name, void **buffer,
 954                                    bool alloc)
 955 {
 956         struct socket_smack *ssp;
 957         struct socket *sock;
 958         struct super_block *sbp;
 959         struct inode *ip = (struct inode *)inode;
 960         char *isp;
 961         int ilen;
 962         int rc = 0;
 963
 964         if (strcmp(name, XATTR_SMACK_SUFFIX) == 0) {
 965                 isp = smk_of_inode(inode);
 966                 ilen = strlen(isp) + 1;
 967                 *buffer = isp;
 968                 return ilen;
 969         }
 970
 971         /*
 972          * The rest of the Smack xattrs are only on sockets.
 973          */
 974         sbp = ip->i_sb;
 975         if (sbp->s_magic != SOCKFS_MAGIC)
 976                 return -EOPNOTSUPP;
 977
 978         sock = SOCKET_I(ip);
 979         if (sock == NULL || sock->sk == NULL)
 980                 return -EOPNOTSUPP;
 981
 982         ssp = sock->sk->sk_security;
 983
 984         if (strcmp(name, XATTR_SMACK_IPIN) == 0)
 985                 isp = ssp->smk_in;
 986         else if (strcmp(name, XATTR_SMACK_IPOUT) == 0)
 987                 isp = ssp->smk_out;
 988         else
 989                 return -EOPNOTSUPP;
 990
 991         ilen = strlen(isp) + 1;
 992         if (rc == 0) {
 993                 *buffer = isp;
 994                 rc = ilen;
 995         }
 996
 997         return rc;
 998 }
 999
1000
1001 /**
1002  * smack_inode_listsecurity - list the Smack attributes
1003  * @inode: the object
1004  * @buffer: where they go
1005  * @buffer_size: size of buffer
1006  *
1007  * Returns 0 on success, -EINVAL otherwise
1008  */
1009 static int smack_inode_listsecurity(struct inode *inode, char *buffer,
1010                                     size_t buffer_size)
1011 {
1012         int len = strlen(XATTR_NAME_SMACK);
1013
1014         if (buffer != NULL && len <= buffer_size) {
1015                 memcpy(buffer, XATTR_NAME_SMACK, len);
1016                 return len;
1017         }
1018         return -EINVAL;
1019 }
1020
1021 /**
1022  * smack_inode_getsecid - Extract inode's security id
1023  * @inode: inode to extract the info from
1024  * @secid: where result will be saved
1025  */
1026 static void smack_inode_getsecid(const struct inode *inode, u32 *secid)
1027 {
1028         struct inode_smack *isp = inode->i_security;
1029
1030         *secid = smack_to_secid(isp->smk_inode);
1031 }
1032
1033 /*
1034  * File Hooks
1035  */
1036
1037 /**
1038  * smack_file_permission - Smack check on file operations
1039  * @file: unused
1040  * @mask: unused
1041  *
1042  * Returns 0
1043  *
1044  * Should access checks be done on each read or write?
1045  * UNICOS and SELinux say yes.
1046  * Trusted Solaris, Trusted Irix, and just about everyone else says no.
1047  *
1048  * I'll say no for now. Smack does not do the frequent
1049  * label changing that SELinux does.
1050  */
1051 static int smack_file_permission(struct file *file, int mask)
1052 {
1053         return 0;
1054 }
1055
1056 /**
1057  * smack_file_alloc_security - assign a file security blob
1058  * @file: the object
1059  *
1060  * The security blob for a file is a pointer to the master
1061  * label list, so no allocation is done.
1062  *
1063  * Returns 0
1064  */
1065 static int smack_file_alloc_security(struct file *file)
1066 {
1067         file->f_security = smk_of_current();
1068         return 0;
1069 }
1070
1071 /**
1072  * smack_file_free_security - clear a file security blob
1073  * @file: the object
1074  *
1075  * The security blob for a file is a pointer to the master
1076  * label list, so no memory is freed.
1077  */
1078 static void smack_file_free_security(struct file *file)
1079 {
1080         file->f_security = NULL;
1081 }
1082
1083 /**
1084  * smack_file_ioctl - Smack check on ioctls
1085  * @file: the object
1086  * @cmd: what to do
1087  * @arg: unused
1088  *
1089  * Relies heavily on the correct use of the ioctl command conventions.
1090  *
1091  * Returns 0 if allowed, error code otherwise
1092  */
1093 static int smack_file_ioctl(struct file *file, unsigned int cmd,
1094                             unsigned long arg)
1095 {
1096         int rc = 0;
1097         struct smk_audit_info ad;
1098
1099         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
1100         smk_ad_setfield_u_fs_path(&ad, file->f_path);
1101
1102         if (_IOC_DIR(cmd) & _IOC_WRITE)
1103                 rc = smk_curacc(file->f_security, MAY_WRITE, &ad);
1104
1105         if (rc == 0 && (_IOC_DIR(cmd) & _IOC_READ))
1106                 rc = smk_curacc(file->f_security, MAY_READ, &ad);
1107
1108         return rc;
1109 }
1110
1111 /**
1112  * smack_file_lock - Smack check on file locking
1113  * @file: the object
1114  * @cmd: unused
1115  *
1116  * Returns 0 if current has write access, error code otherwise
1117  */
1118 static int smack_file_lock(struct file *file, unsigned int cmd)
1119 {
1120         struct smk_audit_info ad;
1121
1122         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
1123         smk_ad_setfield_u_fs_path(&ad, file->f_path);
1124         return smk_curacc(file->f_security, MAY_WRITE, &ad);
1125 }
1126
1127 /**
1128  * smack_file_fcntl - Smack check on fcntl
1129  * @file: the object
1130  * @cmd: what action to check
1131  * @arg: unused
1132  *
1133  * Generally these operations are harmless.
1134  * File locking operations present an obvious mechanism
1135  * for passing information, so they require write access.
1136  *
1137  * Returns 0 if current has access, error code otherwise
1138  */
1139 static int smack_file_fcntl(struct file *file, unsigned int cmd,
1140                             unsigned long arg)
1141 {
1142         struct smk_audit_info ad;
1143         int rc = 0;
1144
1145
1146         switch (cmd) {
1147         case F_GETLK:
1148         case F_SETLK:
1149         case F_SETLKW:
1150         case F_SETOWN:
1151         case F_SETSIG:
1152                 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
1153                 smk_ad_setfield_u_fs_path(&ad, file->f_path);
1154                 rc = smk_curacc(file->f_security, MAY_WRITE, &ad);
1155                 break;
1156         default:
1157                 break;
1158         }
1159
1160         return rc;
1161 }
1162
1163 /**
1164  * smack_file_mmap :
1165  * Check permissions for a mmap operation.  The @file may be NULL, e.g.
1166  * if mapping anonymous memory.
1167  * @file contains the file structure for file to map (may be NULL).
1168  * @reqprot contains the protection requested by the application.
1169  * @prot contains the protection that will be applied by the kernel.
1170  * @flags contains the operational flags.
1171  * Return 0 if permission is granted.
1172  */
1173 static int smack_file_mmap(struct file *file,
1174                            unsigned long reqprot, unsigned long prot,
1175                            unsigned long flags, unsigned long addr,
1176                            unsigned long addr_only)
1177 {
1178         struct smack_known *skp;
1179         struct smack_rule *srp;
1180         struct task_smack *tsp;
1181         char *sp;
1182         char *msmack;
1183         char *osmack;
1184         struct inode_smack *isp;
1185         struct dentry *dp;
1186         int may;
1187         int mmay;
1188         int tmay;
1189         int rc;
1190
1191         /* do DAC check on address space usage */
1192         rc = cap_file_mmap(file, reqprot, prot, flags, addr, addr_only);
1193         if (rc || addr_only)
1194                 return rc;
1195
1196         if (file == NULL || file->f_dentry == NULL)
1197                 return 0;
1198
1199         dp = file->f_dentry;
1200
1201         if (dp->d_inode == NULL)
1202                 return 0;
1203
1204         isp = dp->d_inode->i_security;
1205         if (isp->smk_mmap == NULL)
1206                 return 0;
1207         msmack = isp->smk_mmap;
1208
1209         tsp = current_security();
1210         sp = smk_of_current();
1211         skp = smk_find_entry(sp);
1212         rc = 0;
1213
1214         rcu_read_lock();
1215         /*
1216          * For each Smack rule associated with the subject
1217          * label verify that the SMACK64MMAP also has access
1218          * to that rule's object label.
1219          */
1220         list_for_each_entry_rcu(srp, &skp->smk_rules, list) {
1221                 osmack = srp->smk_object;
1222                 /*
1223                  * Matching labels always allows access.
1224                  */
1225                 if (msmack == osmack)
1226                         continue;
1227                 /*
1228                  * If there is a matching local rule take
1229                  * that into account as well.
1230                  */
1231                 may = smk_access_entry(srp->smk_subject, osmack,
1232                                         &tsp->smk_rules);
1233                 if (may == -ENOENT)
1234                         may = srp->smk_access;
1235                 else
1236                         may &= srp->smk_access;
1237                 /*
1238                  * If may is zero the SMACK64MMAP subject can't
1239                  * possibly have less access.
1240                  */
1241                 if (may == 0)
1242                         continue;
1243
1244                 /*
1245                  * Fetch the global list entry.
1246                  * If there isn't one a SMACK64MMAP subject
1247                  * can't have as much access as current.
1248                  */
1249                 skp = smk_find_entry(msmack);
1250                 mmay = smk_access_entry(msmack, osmack, &skp->smk_rules);
1251                 if (mmay == -ENOENT) {
1252                         rc = -EACCES;
1253                         break;
1254                 }
1255                 /*
1256                  * If there is a local entry it modifies the
1257                  * potential access, too.
1258                  */
1259                 tmay = smk_access_entry(msmack, osmack, &tsp->smk_rules);
1260                 if (tmay != -ENOENT)
1261                         mmay &= tmay;
1262
1263                 /*
1264                  * If there is any access available to current that is
1265                  * not available to a SMACK64MMAP subject
1266                  * deny access.
1267                  */
1268                 if ((may | mmay) != mmay) {
1269                         rc = -EACCES;
1270                         break;
1271                 }
1272         }
1273
1274         rcu_read_unlock();
1275
1276         return rc;
1277 }
1278
1279 /**
1280  * smack_file_set_fowner - set the file security blob value
1281  * @file: object in question
1282  *
1283  * Returns 0
1284  * Further research may be required on this one.
1285  */
1286 static int smack_file_set_fowner(struct file *file)
1287 {
1288         file->f_security = smk_of_current();
1289         return 0;
1290 }
1291
1292 /**
1293  * smack_file_send_sigiotask - Smack on sigio
1294  * @tsk: The target task
1295  * @fown: the object the signal come from
1296  * @signum: unused
1297  *
1298  * Allow a privileged task to get signals even if it shouldn't
1299  *
1300  * Returns 0 if a subject with the object's smack could
1301  * write to the task, an error code otherwise.
1302  */
1303 static int smack_file_send_sigiotask(struct task_struct *tsk,
1304                                      struct fown_struct *fown, int signum)
1305 {
1306         struct file *file;
1307         int rc;
1308         char *tsp = smk_of_task(tsk->cred->security);
1309         struct smk_audit_info ad;
1310
1311         /*
1312          * struct fown_struct is never outside the context of a struct file
1313          */
1314         file = container_of(fown, struct file, f_owner);
1315
1316         /* we don't log here as rc can be overriden */
1317         rc = smk_access(file->f_security, tsp, MAY_WRITE, NULL);
1318         if (rc != 0 && has_capability(tsk, CAP_MAC_OVERRIDE))
1319                 rc = 0;
1320
1321         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
1322         smk_ad_setfield_u_tsk(&ad, tsk);
1323         smack_log(file->f_security, tsp, MAY_WRITE, rc, &ad);
1324         return rc;
1325 }
1326
1327 /**
1328  * smack_file_receive - Smack file receive check
1329  * @file: the object
1330  *
1331  * Returns 0 if current has access, error code otherwise
1332  */
1333 static int smack_file_receive(struct file *file)
1334 {
1335         int may = 0;
1336         struct smk_audit_info ad;
1337
1338         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
1339         smk_ad_setfield_u_fs_path(&ad, file->f_path);
1340         /*
1341          * This code relies on bitmasks.
1342          */
1343         if (file->f_mode & FMODE_READ)
1344                 may = MAY_READ;
1345         if (file->f_mode & FMODE_WRITE)
1346                 may |= MAY_WRITE;
1347
1348         return smk_curacc(file->f_security, may, &ad);
1349 }
1350
1351 /**
1352  * smack_dentry_open - Smack dentry open processing
1353  * @file: the object
1354  * @cred: unused
1355  *
1356  * Set the security blob in the file structure.
1357  *
1358  * Returns 0
1359  */
1360 static int smack_dentry_open(struct file *file, const struct cred *cred)
1361 {
1362         struct inode_smack *isp = file->f_path.dentry->d_inode->i_security;
1363
1364         file->f_security = isp->smk_inode;
1365
1366         return 0;
1367 }
1368
1369 /*
1370  * Task hooks
1371  */
1372
1373 /**
1374  * smack_cred_alloc_blank - "allocate" blank task-level security credentials
1375  * @new: the new credentials
1376  * @gfp: the atomicity of any memory allocations
1377  *
1378  * Prepare a blank set of credentials for modification.  This must allocate all
1379  * the memory the LSM module might require such that cred_transfer() can
1380  * complete without error.
1381  */
1382 static int smack_cred_alloc_blank(struct cred *cred, gfp_t gfp)
1383 {
1384         struct task_smack *tsp;
1385
1386         tsp = new_task_smack(NULL, NULL, gfp);
1387         if (tsp == NULL)
1388                 return -ENOMEM;
1389
1390         cred->security = tsp;
1391
1392         return 0;
1393 }
1394
1395
1396 /**
1397  * smack_cred_free - "free" task-level security credentials
1398  * @cred: the credentials in question
1399  *
1400  */
1401 static void smack_cred_free(struct cred *cred)
1402 {
1403         struct task_smack *tsp = cred->security;
1404         struct smack_rule *rp;
1405         struct list_head *l;
1406         struct list_head *n;
1407
1408         if (tsp == NULL)
1409                 return;
1410         cred->security = NULL;
1411
1412         list_for_each_safe(l, n, &tsp->smk_rules) {
1413                 rp = list_entry(l, struct smack_rule, list);
1414                 list_del(&rp->list);
1415                 kfree(rp);
1416         }
1417         kfree(tsp);
1418 }
1419
1420 /**
1421  * smack_cred_prepare - prepare new set of credentials for modification
1422  * @new: the new credentials
1423  * @old: the original credentials
1424  * @gfp: the atomicity of any memory allocations
1425  *
1426  * Prepare a new set of credentials for modification.
1427  */
1428 static int smack_cred_prepare(struct cred *new, const struct cred *old,
1429                               gfp_t gfp)
1430 {
1431         struct task_smack *old_tsp = old->security;
1432         struct task_smack *new_tsp;
1433         int rc;
1434
1435         new_tsp = new_task_smack(old_tsp->smk_task, old_tsp->smk_task, gfp);
1436         if (new_tsp == NULL)
1437                 return -ENOMEM;
1438
1439         rc = smk_copy_rules(&new_tsp->smk_rules, &old_tsp->smk_rules, gfp);
1440         if (rc != 0)
1441                 return rc;
1442
1443         new->security = new_tsp;
1444         return 0;
1445 }
1446
1447 /**
1448  * smack_cred_transfer - Transfer the old credentials to the new credentials
1449  * @new: the new credentials
1450  * @old: the original credentials
1451  *
1452  * Fill in a set of blank credentials from another set of credentials.
1453  */
1454 static void smack_cred_transfer(struct cred *new, const struct cred *old)
1455 {
1456         struct task_smack *old_tsp = old->security;
1457         struct task_smack *new_tsp = new->security;
1458
1459         new_tsp->smk_task = old_tsp->smk_task;
1460         new_tsp->smk_forked = old_tsp->smk_task;
1461         mutex_init(&new_tsp->smk_rules_lock);
1462         INIT_LIST_HEAD(&new_tsp->smk_rules);
1463
1464
1465         /* cbs copy rule list */
1466 }
1467
1468 /**
1469  * smack_kernel_act_as - Set the subjective context in a set of credentials
1470  * @new: points to the set of credentials to be modified.
1471  * @secid: specifies the security ID to be set
1472  *
1473  * Set the security data for a kernel service.
1474  */
1475 static int smack_kernel_act_as(struct cred *new, u32 secid)
1476 {
1477         struct task_smack *new_tsp = new->security;
1478         char *smack = smack_from_secid(secid);
1479
1480         if (smack == NULL)
1481                 return -EINVAL;
1482
1483         new_tsp->smk_task = smack;
1484         return 0;
1485 }
1486
1487 /**
1488  * smack_kernel_create_files_as - Set the file creation label in a set of creds
1489  * @new: points to the set of credentials to be modified
1490  * @inode: points to the inode to use as a reference
1491  *
1492  * Set the file creation context in a set of credentials to the same
1493  * as the objective context of the specified inode
1494  */
1495 static int smack_kernel_create_files_as(struct cred *new,
1496                                         struct inode *inode)
1497 {
1498         struct inode_smack *isp = inode->i_security;
1499         struct task_smack *tsp = new->security;
1500
1501         tsp->smk_forked = isp->smk_inode;
1502         tsp->smk_task = isp->smk_inode;
1503         return 0;
1504 }
1505
1506 /**
1507  * smk_curacc_on_task - helper to log task related access
1508  * @p: the task object
1509  * @access: the access requested
1510  * @caller: name of the calling function for audit
1511  *
1512  * Return 0 if access is permitted
1513  */
1514 static int smk_curacc_on_task(struct task_struct *p, int access,
1515                                 const char *caller)
1516 {
1517         struct smk_audit_info ad;
1518
1519         smk_ad_init(&ad, caller, LSM_AUDIT_DATA_TASK);
1520         smk_ad_setfield_u_tsk(&ad, p);
1521         return smk_curacc(smk_of_task(task_security(p)), access, &ad);
1522 }
1523
1524 /**
1525  * smack_task_setpgid - Smack check on setting pgid
1526  * @p: the task object
1527  * @pgid: unused
1528  *
1529  * Return 0 if write access is permitted
1530  */
1531 static int smack_task_setpgid(struct task_struct *p, pid_t pgid)
1532 {
1533         return smk_curacc_on_task(p, MAY_WRITE, __func__);
1534 }
1535
1536 /**
1537  * smack_task_getpgid - Smack access check for getpgid
1538  * @p: the object task
1539  *
1540  * Returns 0 if current can read the object task, error code otherwise
1541  */
1542 static int smack_task_getpgid(struct task_struct *p)
1543 {
1544         return smk_curacc_on_task(p, MAY_READ, __func__);
1545 }
1546
1547 /**
1548  * smack_task_getsid - Smack access check for getsid
1549  * @p: the object task
1550  *
1551  * Returns 0 if current can read the object task, error code otherwise
1552  */
1553 static int smack_task_getsid(struct task_struct *p)
1554 {
1555         return smk_curacc_on_task(p, MAY_READ, __func__);
1556 }
1557
1558 /**
1559  * smack_task_getsecid - get the secid of the task
1560  * @p: the object task
1561  * @secid: where to put the result
1562  *
1563  * Sets the secid to contain a u32 version of the smack label.
1564  */
1565 static void smack_task_getsecid(struct task_struct *p, u32 *secid)
1566 {
1567         *secid = smack_to_secid(smk_of_task(task_security(p)));
1568 }
1569
1570 /**
1571  * smack_task_setnice - Smack check on setting nice
1572  * @p: the task object
1573  * @nice: unused
1574  *
1575  * Return 0 if write access is permitted
1576  */
1577 static int smack_task_setnice(struct task_struct *p, int nice)
1578 {
1579         int rc;
1580
1581         rc = cap_task_setnice(p, nice);
1582         if (rc == 0)
1583                 rc = smk_curacc_on_task(p, MAY_WRITE, __func__);
1584         return rc;
1585 }
1586
1587 /**
1588  * smack_task_setioprio - Smack check on setting ioprio
1589  * @p: the task object
1590  * @ioprio: unused
1591  *
1592  * Return 0 if write access is permitted
1593  */
1594 static int smack_task_setioprio(struct task_struct *p, int ioprio)
1595 {
1596         int rc;
1597
1598         rc = cap_task_setioprio(p, ioprio);
1599         if (rc == 0)
1600                 rc = smk_curacc_on_task(p, MAY_WRITE, __func__);
1601         return rc;
1602 }
1603
1604 /**
1605  * smack_task_getioprio - Smack check on reading ioprio
1606  * @p: the task object
1607  *
1608  * Return 0 if read access is permitted
1609  */
1610 static int smack_task_getioprio(struct task_struct *p)
1611 {
1612         return smk_curacc_on_task(p, MAY_READ, __func__);
1613 }
1614
1615 /**
1616  * smack_task_setscheduler - Smack check on setting scheduler
1617  * @p: the task object
1618  * @policy: unused
1619  * @lp: unused
1620  *
1621  * Return 0 if read access is permitted
1622  */
1623 static int smack_task_setscheduler(struct task_struct *p)
1624 {
1625         int rc;
1626
1627         rc = cap_task_setscheduler(p);
1628         if (rc == 0)
1629                 rc = smk_curacc_on_task(p, MAY_WRITE, __func__);
1630         return rc;
1631 }
1632
1633 /**
1634  * smack_task_getscheduler - Smack check on reading scheduler
1635  * @p: the task object
1636  *
1637  * Return 0 if read access is permitted
1638  */
1639 static int smack_task_getscheduler(struct task_struct *p)
1640 {
1641         return smk_curacc_on_task(p, MAY_READ, __func__);
1642 }
1643
1644 /**
1645  * smack_task_movememory - Smack check on moving memory
1646  * @p: the task object
1647  *
1648  * Return 0 if write access is permitted
1649  */
1650 static int smack_task_movememory(struct task_struct *p)
1651 {
1652         return smk_curacc_on_task(p, MAY_WRITE, __func__);
1653 }
1654
1655 /**
1656  * smack_task_kill - Smack check on signal delivery
1657  * @p: the task object
1658  * @info: unused
1659  * @sig: unused
1660  * @secid: identifies the smack to use in lieu of current's
1661  *
1662  * Return 0 if write access is permitted
1663  *
1664  * The secid behavior is an artifact of an SELinux hack
1665  * in the USB code. Someday it may go away.
1666  */
1667 static int smack_task_kill(struct task_struct *p, struct siginfo *info,
1668                            int sig, u32 secid)
1669 {
1670         struct smk_audit_info ad;
1671
1672         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
1673         smk_ad_setfield_u_tsk(&ad, p);
1674         /*
1675          * Sending a signal requires that the sender
1676          * can write the receiver.
1677          */
1678         if (secid == 0)
1679                 return smk_curacc(smk_of_task(task_security(p)), MAY_WRITE,
1680                                   &ad);
1681         /*
1682          * If the secid isn't 0 we're dealing with some USB IO
1683          * specific behavior. This is not clean. For one thing
1684          * we can't take privilege into account.
1685          */
1686         return smk_access(smack_from_secid(secid),
1687                           smk_of_task(task_security(p)), MAY_WRITE, &ad);
1688 }
1689
1690 /**
1691  * smack_task_wait - Smack access check for waiting
1692  * @p: task to wait for
1693  *
1694  * Returns 0 if current can wait for p, error code otherwise
1695  */
1696 static int smack_task_wait(struct task_struct *p)
1697 {
1698         struct smk_audit_info ad;
1699         char *sp = smk_of_current();
1700         char *tsp = smk_of_forked(task_security(p));
1701         int rc;
1702
1703         /* we don't log here, we can be overriden */
1704         rc = smk_access(tsp, sp, MAY_WRITE, NULL);
1705         if (rc == 0)
1706                 goto out_log;
1707
1708         /*
1709          * Allow the operation to succeed if either task
1710          * has privilege to perform operations that might
1711          * account for the smack labels having gotten to
1712          * be different in the first place.
1713          *
1714          * This breaks the strict subject/object access
1715          * control ideal, taking the object's privilege
1716          * state into account in the decision as well as
1717          * the smack value.
1718          */
1719         if (capable(CAP_MAC_OVERRIDE) || has_capability(p, CAP_MAC_OVERRIDE))
1720                 rc = 0;
1721         /* we log only if we didn't get overriden */
1722  out_log:
1723         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
1724         smk_ad_setfield_u_tsk(&ad, p);
1725         smack_log(tsp, sp, MAY_WRITE, rc, &ad);
1726         return rc;
1727 }
1728
1729 /**
1730  * smack_task_to_inode - copy task smack into the inode blob
1731  * @p: task to copy from
1732  * @inode: inode to copy to
1733  *
1734  * Sets the smack pointer in the inode security blob
1735  */
1736 static void smack_task_to_inode(struct task_struct *p, struct inode *inode)
1737 {
1738         struct inode_smack *isp = inode->i_security;
1739         isp->smk_inode = smk_of_task(task_security(p));
1740 }
1741
1742 /*
1743  * Socket hooks.
1744  */
1745
1746 /**
1747  * smack_sk_alloc_security - Allocate a socket blob
1748  * @sk: the socket
1749  * @family: unused
1750  * @gfp_flags: memory allocation flags
1751  *
1752  * Assign Smack pointers to current
1753  *
1754  * Returns 0 on success, -ENOMEM is there's no memory
1755  */
1756 static int smack_sk_alloc_security(struct sock *sk, int family, gfp_t gfp_flags)
1757 {
1758         char *csp = smk_of_current();
1759         struct socket_smack *ssp;
1760
1761         ssp = kzalloc(sizeof(struct socket_smack), gfp_flags);
1762         if (ssp == NULL)
1763                 return -ENOMEM;
1764
1765         ssp->smk_in = csp;
1766         ssp->smk_out = csp;
1767         ssp->smk_packet = NULL;
1768
1769         sk->sk_security = ssp;
1770
1771         return 0;
1772 }
1773
1774 /**
1775  * smack_sk_free_security - Free a socket blob
1776  * @sk: the socket
1777  *
1778  * Clears the blob pointer
1779  */
1780 static void smack_sk_free_security(struct sock *sk)
1781 {
1782         kfree(sk->sk_security);
1783 }
1784
1785 /**
1786 * smack_host_label - check host based restrictions
1787 * @sip: the object end
1788 *
1789 * looks for host based access restrictions
1790 *
1791 * This version will only be appropriate for really small sets of single label
1792 * hosts.  The caller is responsible for ensuring that the RCU read lock is
1793 * taken before calling this function.
1794 *
1795 * Returns the label of the far end or NULL if it's not special.
1796 */
1797 static char *smack_host_label(struct sockaddr_in *sip)
1798 {
1799         struct smk_netlbladdr *snp;
1800         struct in_addr *siap = &sip->sin_addr;
1801
1802         if (siap->s_addr == 0)
1803                 return NULL;
1804
1805         list_for_each_entry_rcu(snp, &smk_netlbladdr_list, list)
1806                 /*
1807                 * we break after finding the first match because
1808                 * the list is sorted from longest to shortest mask
1809                 * so we have found the most specific match
1810                 */
1811                 if ((&snp->smk_host.sin_addr)->s_addr ==
1812                     (siap->s_addr & (&snp->smk_mask)->s_addr)) {
1813                         /* we have found the special CIPSO option */
1814                         if (snp->smk_label == smack_cipso_option)
1815                                 return NULL;
1816                         return snp->smk_label;
1817                 }
1818
1819         return NULL;
1820 }
1821
1822 /**
1823  * smack_set_catset - convert a capset to netlabel mls categories
1824  * @catset: the Smack categories
1825  * @sap: where to put the netlabel categories
1826  *
1827  * Allocates and fills attr.mls.cat
1828  */
1829 static void smack_set_catset(char *catset, struct netlbl_lsm_secattr *sap)
1830 {
1831         unsigned char *cp;
1832         unsigned char m;
1833         int cat;
1834         int rc;
1835         int byte;
1836
1837         if (!catset)
1838                 return;
1839
1840         sap->flags |= NETLBL_SECATTR_MLS_CAT;
1841         sap->attr.mls.cat = netlbl_secattr_catmap_alloc(GFP_ATOMIC);
1842         sap->attr.mls.cat->startbit = 0;
1843
1844         for (cat = 1, cp = catset, byte = 0; byte < SMK_LABELLEN; cp++, byte++)
1845                 for (m = 0x80; m != 0; m >>= 1, cat++) {
1846                         if ((m & *cp) == 0)
1847                                 continue;
1848                         rc = netlbl_secattr_catmap_setbit(sap->attr.mls.cat,
1849                                                           cat, GFP_ATOMIC);
1850                 }
1851 }
1852
1853 /**
1854  * smack_to_secattr - fill a secattr from a smack value
1855  * @smack: the smack value
1856  * @nlsp: where the result goes
1857  *
1858  * Casey says that CIPSO is good enough for now.
1859  * It can be used to effect.
1860  * It can also be abused to effect when necessary.
1861  * Apologies to the TSIG group in general and GW in particular.
1862  */
1863 static void smack_to_secattr(char *smack, struct netlbl_lsm_secattr *nlsp)
1864 {
1865         struct smack_cipso cipso;
1866         int rc;
1867
1868         nlsp->domain = smack;
1869         nlsp->flags = NETLBL_SECATTR_DOMAIN | NETLBL_SECATTR_MLS_LVL;
1870
1871         rc = smack_to_cipso(smack, &cipso);
1872         if (rc == 0) {
1873                 nlsp->attr.mls.lvl = cipso.smk_level;
1874                 smack_set_catset(cipso.smk_catset, nlsp);
1875         } else {
1876                 nlsp->attr.mls.lvl = smack_cipso_direct;
1877                 smack_set_catset(smack, nlsp);
1878         }
1879 }
1880
1881 /**
1882  * smack_netlabel - Set the secattr on a socket
1883  * @sk: the socket
1884  * @labeled: socket label scheme
1885  *
1886  * Convert the outbound smack value (smk_out) to a
1887  * secattr and attach it to the socket.
1888  *
1889  * Returns 0 on success or an error code
1890  */
1891 static int smack_netlabel(struct sock *sk, int labeled)
1892 {
1893         struct socket_smack *ssp = sk->sk_security;
1894         struct netlbl_lsm_secattr secattr;
1895         int rc = 0;
1896
1897         /*
1898          * Usually the netlabel code will handle changing the
1899          * packet labeling based on the label.
1900          * The case of a single label host is different, because
1901          * a single label host should never get a labeled packet
1902          * even though the label is usually associated with a packet
1903          * label.
1904          */
1905         local_bh_disable();
1906         bh_lock_sock_nested(sk);
1907
1908         if (ssp->smk_out == smack_net_ambient ||
1909             labeled == SMACK_UNLABELED_SOCKET)
1910                 netlbl_sock_delattr(sk);
1911         else {
1912                 netlbl_secattr_init(&secattr);
1913                 smack_to_secattr(ssp->smk_out, &secattr);
1914                 rc = netlbl_sock_setattr(sk, sk->sk_family, &secattr);
1915                 netlbl_secattr_destroy(&secattr);
1916         }
1917
1918         bh_unlock_sock(sk);
1919         local_bh_enable();
1920
1921         return rc;
1922 }
1923
1924 /**
1925  * smack_netlbel_send - Set the secattr on a socket and perform access checks
1926  * @sk: the socket
1927  * @sap: the destination address
1928  *
1929  * Set the correct secattr for the given socket based on the destination
1930  * address and perform any outbound access checks needed.
1931  *
1932  * Returns 0 on success or an error code.
1933  *
1934  */
1935 static int smack_netlabel_send(struct sock *sk, struct sockaddr_in *sap)
1936 {
1937         int rc;
1938         int sk_lbl;
1939         char *hostsp;
1940         struct socket_smack *ssp = sk->sk_security;
1941         struct smk_audit_info ad;
1942
1943         rcu_read_lock();
1944         hostsp = smack_host_label(sap);
1945         if (hostsp != NULL) {
1946 #ifdef CONFIG_AUDIT
1947                 struct lsm_network_audit net;
1948
1949                 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
1950                 ad.a.u.net->family = sap->sin_family;
1951                 ad.a.u.net->dport = sap->sin_port;
1952                 ad.a.u.net->v4info.daddr = sap->sin_addr.s_addr;
1953 #endif
1954                 sk_lbl = SMACK_UNLABELED_SOCKET;
1955                 rc = smk_access(ssp->smk_out, hostsp, MAY_WRITE, &ad);
1956         } else {
1957                 sk_lbl = SMACK_CIPSO_SOCKET;
1958                 rc = 0;
1959         }
1960         rcu_read_unlock();
1961         if (rc != 0)
1962                 return rc;
1963
1964         return smack_netlabel(sk, sk_lbl);
1965 }
1966
1967 /**
1968  * smack_inode_setsecurity - set smack xattrs
1969  * @inode: the object
1970  * @name: attribute name
1971  * @value: attribute value
1972  * @size: size of the attribute
1973  * @flags: unused
1974  *
1975  * Sets the named attribute in the appropriate blob
1976  *
1977  * Returns 0 on success, or an error code
1978  */
1979 static int smack_inode_setsecurity(struct inode *inode, const char *name,
1980                                    const void *value, size_t size, int flags)
1981 {
1982         char *sp;
1983         struct inode_smack *nsp = inode->i_security;
1984         struct socket_smack *ssp;
1985         struct socket *sock;
1986         int rc = 0;
1987
1988         if (value == NULL || size > SMK_LABELLEN || size == 0)
1989                 return -EACCES;
1990
1991         sp = smk_import(value, size);
1992         if (sp == NULL)
1993                 return -EINVAL;
1994
1995         if (strcmp(name, XATTR_SMACK_SUFFIX) == 0) {
1996                 nsp->smk_inode = sp;
1997                 nsp->smk_flags |= SMK_INODE_INSTANT;
1998                 return 0;
1999         }
2000         /*
2001          * The rest of the Smack xattrs are only on sockets.
2002          */
2003         if (inode->i_sb->s_magic != SOCKFS_MAGIC)
2004                 return -EOPNOTSUPP;
2005
2006         sock = SOCKET_I(inode);
2007         if (sock == NULL || sock->sk == NULL)
2008                 return -EOPNOTSUPP;
2009
2010         ssp = sock->sk->sk_security;
2011
2012         if (strcmp(name, XATTR_SMACK_IPIN) == 0)
2013                 ssp->smk_in = sp;
2014         else if (strcmp(name, XATTR_SMACK_IPOUT) == 0) {
2015                 ssp->smk_out = sp;
2016                 if (sock->sk->sk_family != PF_UNIX) {
2017                         rc = smack_netlabel(sock->sk, SMACK_CIPSO_SOCKET);
2018                         if (rc != 0)
2019                                 printk(KERN_WARNING
2020                                         "Smack: \"%s\" netlbl error %d.\n",
2021                                         __func__, -rc);
2022                 }
2023         } else
2024                 return -EOPNOTSUPP;
2025
2026         return 0;
2027 }
2028
2029 /**
2030  * smack_socket_post_create - finish socket setup
2031  * @sock: the socket
2032  * @family: protocol family
2033  * @type: unused
2034  * @protocol: unused
2035  * @kern: unused
2036  *
2037  * Sets the netlabel information on the socket
2038  *
2039  * Returns 0 on success, and error code otherwise
2040  */
2041 static int smack_socket_post_create(struct socket *sock, int family,
2042                                     int type, int protocol, int kern)
2043 {
2044         if (family != PF_INET || sock->sk == NULL)
2045                 return 0;
2046         /*
2047          * Set the outbound netlbl.
2048          */
2049         return smack_netlabel(sock->sk, SMACK_CIPSO_SOCKET);
2050 }
2051
2052 /**
2053  * smack_socket_connect - connect access check
2054  * @sock: the socket
2055  * @sap: the other end
2056  * @addrlen: size of sap
2057  *
2058  * Verifies that a connection may be possible
2059  *
2060  * Returns 0 on success, and error code otherwise
2061  */
2062 static int smack_socket_connect(struct socket *sock, struct sockaddr *sap,
2063                                 int addrlen)
2064 {
2065         if (sock->sk == NULL || sock->sk->sk_family != PF_INET)
2066                 return 0;
2067         if (addrlen < sizeof(struct sockaddr_in))
2068                 return -EINVAL;
2069
2070         return smack_netlabel_send(sock->sk, (struct sockaddr_in *)sap);
2071 }
2072
2073 /**
2074  * smack_flags_to_may - convert S_ to MAY_ values
2075  * @flags: the S_ value
2076  *
2077  * Returns the equivalent MAY_ value
2078  */
2079 static int smack_flags_to_may(int flags)
2080 {
2081         int may = 0;
2082
2083         if (flags & S_IRUGO)
2084                 may |= MAY_READ;
2085         if (flags & S_IWUGO)
2086                 may |= MAY_WRITE;
2087         if (flags & S_IXUGO)
2088                 may |= MAY_EXEC;
2089
2090         return may;
2091 }
2092
2093 /**
2094  * smack_msg_msg_alloc_security - Set the security blob for msg_msg
2095  * @msg: the object
2096  *
2097  * Returns 0
2098  */
2099 static int smack_msg_msg_alloc_security(struct msg_msg *msg)
2100 {
2101         msg->security = smk_of_current();
2102         return 0;
2103 }
2104
2105 /**
2106  * smack_msg_msg_free_security - Clear the security blob for msg_msg
2107  * @msg: the object
2108  *
2109  * Clears the blob pointer
2110  */
2111 static void smack_msg_msg_free_security(struct msg_msg *msg)
2112 {
2113         msg->security = NULL;
2114 }
2115
2116 /**
2117  * smack_of_shm - the smack pointer for the shm
2118  * @shp: the object
2119  *
2120  * Returns a pointer to the smack value
2121  */
2122 static char *smack_of_shm(struct shmid_kernel *shp)
2123 {
2124         return (char *)shp->shm_perm.security;
2125 }
2126
2127 /**
2128  * smack_shm_alloc_security - Set the security blob for shm
2129  * @shp: the object
2130  *
2131  * Returns 0
2132  */
2133 static int smack_shm_alloc_security(struct shmid_kernel *shp)
2134 {
2135         struct kern_ipc_perm *isp = &shp->shm_perm;
2136
2137         isp->security = smk_of_current();
2138         return 0;
2139 }
2140
2141 /**
2142  * smack_shm_free_security - Clear the security blob for shm
2143  * @shp: the object
2144  *
2145  * Clears the blob pointer
2146  */
2147 static void smack_shm_free_security(struct shmid_kernel *shp)
2148 {
2149         struct kern_ipc_perm *isp = &shp->shm_perm;
2150
2151         isp->security = NULL;
2152 }
2153
2154 /**
2155  * smk_curacc_shm : check if current has access on shm
2156  * @shp : the object
2157  * @access : access requested
2158  *
2159  * Returns 0 if current has the requested access, error code otherwise
2160  */
2161 static int smk_curacc_shm(struct shmid_kernel *shp, int access)
2162 {
2163         char *ssp = smack_of_shm(shp);
2164         struct smk_audit_info ad;
2165
2166 #ifdef CONFIG_AUDIT
2167         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
2168         ad.a.u.ipc_id = shp->shm_perm.id;
2169 #endif
2170         return smk_curacc(ssp, access, &ad);
2171 }
2172
2173 /**
2174  * smack_shm_associate - Smack access check for shm
2175  * @shp: the object
2176  * @shmflg: access requested
2177  *
2178  * Returns 0 if current has the requested access, error code otherwise
2179  */
2180 static int smack_shm_associate(struct shmid_kernel *shp, int shmflg)
2181 {
2182         int may;
2183
2184         may = smack_flags_to_may(shmflg);
2185         return smk_curacc_shm(shp, may);
2186 }
2187
2188 /**
2189  * smack_shm_shmctl - Smack access check for shm
2190  * @shp: the object
2191  * @cmd: what it wants to do
2192  *
2193  * Returns 0 if current has the requested access, error code otherwise
2194  */
2195 static int smack_shm_shmctl(struct shmid_kernel *shp, int cmd)
2196 {
2197         int may;
2198
2199         switch (cmd) {
2200         case IPC_STAT:
2201         case SHM_STAT:
2202                 may = MAY_READ;
2203                 break;
2204         case IPC_SET:
2205         case SHM_LOCK:
2206         case SHM_UNLOCK:
2207         case IPC_RMID:
2208                 may = MAY_READWRITE;
2209                 break;
2210         case IPC_INFO:
2211         case SHM_INFO:
2212                 /*
2213                  * System level information.
2214                  */
2215                 return 0;
2216         default:
2217                 return -EINVAL;
2218         }
2219         return smk_curacc_shm(shp, may);
2220 }
2221
2222 /**
2223  * smack_shm_shmat - Smack access for shmat
2224  * @shp: the object
2225  * @shmaddr: unused
2226  * @shmflg: access requested
2227  *
2228  * Returns 0 if current has the requested access, error code otherwise
2229  */
2230 static int smack_shm_shmat(struct shmid_kernel *shp, char __user *shmaddr,
2231                            int shmflg)
2232 {
2233         int may;
2234
2235         may = smack_flags_to_may(shmflg);
2236         return smk_curacc_shm(shp, may);
2237 }
2238
2239 /**
2240  * smack_of_sem - the smack pointer for the sem
2241  * @sma: the object
2242  *
2243  * Returns a pointer to the smack value
2244  */
2245 static char *smack_of_sem(struct sem_array *sma)
2246 {
2247         return (char *)sma->sem_perm.security;
2248 }
2249
2250 /**
2251  * smack_sem_alloc_security - Set the security blob for sem
2252  * @sma: the object
2253  *
2254  * Returns 0
2255  */
2256 static int smack_sem_alloc_security(struct sem_array *sma)
2257 {
2258         struct kern_ipc_perm *isp = &sma->sem_perm;
2259
2260         isp->security = smk_of_current();
2261         return 0;
2262 }
2263
2264 /**
2265  * smack_sem_free_security - Clear the security blob for sem
2266  * @sma: the object
2267  *
2268  * Clears the blob pointer
2269  */
2270 static void smack_sem_free_security(struct sem_array *sma)
2271 {
2272         struct kern_ipc_perm *isp = &sma->sem_perm;
2273
2274         isp->security = NULL;
2275 }
2276
2277 /**
2278  * smk_curacc_sem : check if current has access on sem
2279  * @sma : the object
2280  * @access : access requested
2281  *
2282  * Returns 0 if current has the requested access, error code otherwise
2283  */
2284 static int smk_curacc_sem(struct sem_array *sma, int access)
2285 {
2286         char *ssp = smack_of_sem(sma);
2287         struct smk_audit_info ad;
2288
2289 #ifdef CONFIG_AUDIT
2290         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
2291         ad.a.u.ipc_id = sma->sem_perm.id;
2292 #endif
2293         return smk_curacc(ssp, access, &ad);
2294 }
2295
2296 /**
2297  * smack_sem_associate - Smack access check for sem
2298  * @sma: the object
2299  * @semflg: access requested
2300  *
2301  * Returns 0 if current has the requested access, error code otherwise
2302  */
2303 static int smack_sem_associate(struct sem_array *sma, int semflg)
2304 {
2305         int may;
2306
2307         may = smack_flags_to_may(semflg);
2308         return smk_curacc_sem(sma, may);
2309 }
2310
2311 /**
2312  * smack_sem_shmctl - Smack access check for sem
2313  * @sma: the object
2314  * @cmd: what it wants to do
2315  *
2316  * Returns 0 if current has the requested access, error code otherwise
2317  */
2318 static int smack_sem_semctl(struct sem_array *sma, int cmd)
2319 {
2320         int may;
2321
2322         switch (cmd) {
2323         case GETPID:
2324         case GETNCNT:
2325         case GETZCNT:
2326         case GETVAL:
2327         case GETALL:
2328         case IPC_STAT:
2329         case SEM_STAT:
2330                 may = MAY_READ;
2331                 break;
2332         case SETVAL:
2333         case SETALL:
2334         case IPC_RMID:
2335         case IPC_SET:
2336                 may = MAY_READWRITE;
2337                 break;
2338         case IPC_INFO:
2339         case SEM_INFO:
2340                 /*
2341                  * System level information
2342                  */
2343                 return 0;
2344         default:
2345                 return -EINVAL;
2346         }
2347
2348         return smk_curacc_sem(sma, may);
2349 }
2350
2351 /**
2352  * smack_sem_semop - Smack checks of semaphore operations
2353  * @sma: the object
2354  * @sops: unused
2355  * @nsops: unused
2356  * @alter: unused
2357  *
2358  * Treated as read and write in all cases.
2359  *
2360  * Returns 0 if access is allowed, error code otherwise
2361  */
2362 static int smack_sem_semop(struct sem_array *sma, struct sembuf *sops,
2363                            unsigned nsops, int alter)
2364 {
2365         return smk_curacc_sem(sma, MAY_READWRITE);
2366 }
2367
2368 /**
2369  * smack_msg_alloc_security - Set the security blob for msg
2370  * @msq: the object
2371  *
2372  * Returns 0
2373  */
2374 static int smack_msg_queue_alloc_security(struct msg_queue *msq)
2375 {
2376         struct kern_ipc_perm *kisp = &msq->q_perm;
2377
2378         kisp->security = smk_of_current();
2379         return 0;
2380 }
2381
2382 /**
2383  * smack_msg_free_security - Clear the security blob for msg
2384  * @msq: the object
2385  *
2386  * Clears the blob pointer
2387  */
2388 static void smack_msg_queue_free_security(struct msg_queue *msq)
2389 {
2390         struct kern_ipc_perm *kisp = &msq->q_perm;
2391
2392         kisp->security = NULL;
2393 }
2394
2395 /**
2396  * smack_of_msq - the smack pointer for the msq
2397  * @msq: the object
2398  *
2399  * Returns a pointer to the smack value
2400  */
2401 static char *smack_of_msq(struct msg_queue *msq)
2402 {
2403         return (char *)msq->q_perm.security;
2404 }
2405
2406 /**
2407  * smk_curacc_msq : helper to check if current has access on msq
2408  * @msq : the msq
2409  * @access : access requested
2410  *
2411  * return 0 if current has access, error otherwise
2412  */
2413 static int smk_curacc_msq(struct msg_queue *msq, int access)
2414 {
2415         char *msp = smack_of_msq(msq);
2416         struct smk_audit_info ad;
2417
2418 #ifdef CONFIG_AUDIT
2419         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
2420         ad.a.u.ipc_id = msq->q_perm.id;
2421 #endif
2422         return smk_curacc(msp, access, &ad);
2423 }
2424
2425 /**
2426  * smack_msg_queue_associate - Smack access check for msg_queue
2427  * @msq: the object
2428  * @msqflg: access requested
2429  *
2430  * Returns 0 if current has the requested access, error code otherwise
2431  */
2432 static int smack_msg_queue_associate(struct msg_queue *msq, int msqflg)
2433 {
2434         int may;
2435
2436         may = smack_flags_to_may(msqflg);
2437         return smk_curacc_msq(msq, may);
2438 }
2439
2440 /**
2441  * smack_msg_queue_msgctl - Smack access check for msg_queue
2442  * @msq: the object
2443  * @cmd: what it wants to do
2444  *
2445  * Returns 0 if current has the requested access, error code otherwise
2446  */
2447 static int smack_msg_queue_msgctl(struct msg_queue *msq, int cmd)
2448 {
2449         int may;
2450
2451         switch (cmd) {
2452         case IPC_STAT:
2453         case MSG_STAT:
2454                 may = MAY_READ;
2455                 break;
2456         case IPC_SET:
2457         case IPC_RMID:
2458                 may = MAY_READWRITE;
2459                 break;
2460         case IPC_INFO:
2461         case MSG_INFO:
2462                 /*
2463                  * System level information
2464                  */
2465                 return 0;
2466         default:
2467                 return -EINVAL;
2468         }
2469
2470         return smk_curacc_msq(msq, may);
2471 }
2472
2473 /**
2474  * smack_msg_queue_msgsnd - Smack access check for msg_queue
2475  * @msq: the object
2476  * @msg: unused
2477  * @msqflg: access requested
2478  *
2479  * Returns 0 if current has the requested access, error code otherwise
2480  */
2481 static int smack_msg_queue_msgsnd(struct msg_queue *msq, struct msg_msg *msg,
2482                                   int msqflg)
2483 {
2484         int may;
2485
2486         may = smack_flags_to_may(msqflg);
2487         return smk_curacc_msq(msq, may);
2488 }
2489
2490 /**
2491  * smack_msg_queue_msgsnd - Smack access check for msg_queue
2492  * @msq: the object
2493  * @msg: unused
2494  * @target: unused
2495  * @type: unused
2496  * @mode: unused
2497  *
2498  * Returns 0 if current has read and write access, error code otherwise
2499  */
2500 static int smack_msg_queue_msgrcv(struct msg_queue *msq, struct msg_msg *msg,
2501                         struct task_struct *target, long type, int mode)
2502 {
2503         return smk_curacc_msq(msq, MAY_READWRITE);
2504 }
2505
2506 /**
2507  * smack_ipc_permission - Smack access for ipc_permission()
2508  * @ipp: the object permissions
2509  * @flag: access requested
2510  *
2511  * Returns 0 if current has read and write access, error code otherwise
2512  */
2513 static int smack_ipc_permission(struct kern_ipc_perm *ipp, short flag)
2514 {
2515         char *isp = ipp->security;
2516         int may = smack_flags_to_may(flag);
2517         struct smk_audit_info ad;
2518
2519 #ifdef CONFIG_AUDIT
2520         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
2521         ad.a.u.ipc_id = ipp->id;
2522 #endif
2523         return smk_curacc(isp, may, &ad);
2524 }
2525
2526 /**
2527  * smack_ipc_getsecid - Extract smack security id
2528  * @ipp: the object permissions
2529  * @secid: where result will be saved
2530  */
2531 static void smack_ipc_getsecid(struct kern_ipc_perm *ipp, u32 *secid)
2532 {
2533         char *smack = ipp->security;
2534
2535         *secid = smack_to_secid(smack);
2536 }
2537
2538 /**
2539  * smack_d_instantiate - Make sure the blob is correct on an inode
2540  * @opt_dentry: dentry where inode will be attached
2541  * @inode: the object
2542  *
2543  * Set the inode's security blob if it hasn't been done already.
2544  */
2545 static void smack_d_instantiate(struct dentry *opt_dentry, struct inode *inode)
2546 {
2547         struct super_block *sbp;
2548         struct superblock_smack *sbsp;
2549         struct inode_smack *isp;
2550         char *csp = smk_of_current();
2551         char *fetched;
2552         char *final;
2553         char trattr[TRANS_TRUE_SIZE];
2554         int transflag = 0;
2555         struct dentry *dp;
2556
2557         if (inode == NULL)
2558                 return;
2559
2560         isp = inode->i_security;
2561
2562         mutex_lock(&isp->smk_lock);
2563         /*
2564          * If the inode is already instantiated
2565          * take the quick way out
2566          */
2567         if (isp->smk_flags & SMK_INODE_INSTANT)
2568                 goto unlockandout;
2569
2570         sbp = inode->i_sb;
2571         sbsp = sbp->s_security;
2572         /*
2573          * We're going to use the superblock default label
2574          * if there's no label on the file.
2575          */
2576         final = sbsp->smk_default;
2577
2578         /*
2579          * If this is the root inode the superblock
2580          * may be in the process of initialization.
2581          * If that is the case use the root value out
2582          * of the superblock.
2583          */
2584         if (opt_dentry->d_parent == opt_dentry) {
2585                 isp->smk_inode = sbsp->smk_root;
2586                 isp->smk_flags |= SMK_INODE_INSTANT;
2587                 goto unlockandout;
2588         }
2589
2590         /*
2591          * This is pretty hackish.
2592          * Casey says that we shouldn't have to do
2593          * file system specific code, but it does help
2594          * with keeping it simple.
2595          */
2596         switch (sbp->s_magic) {
2597         case SMACK_MAGIC:
2598                 /*
2599                  * Casey says that it's a little embarrassing
2600                  * that the smack file system doesn't do
2601                  * extended attributes.
2602                  */
2603                 final = smack_known_star.smk_known;
2604                 break;
2605         case PIPEFS_MAGIC:
2606                 /*
2607                  * Casey says pipes are easy (?)
2608                  */
2609                 final = smack_known_star.smk_known;
2610                 break;
2611         case DEVPTS_SUPER_MAGIC:
2612                 /*
2613                  * devpts seems content with the label of the task.
2614                  * Programs that change smack have to treat the
2615                  * pty with respect.
2616                  */
2617                 final = csp;
2618                 break;
2619         case SOCKFS_MAGIC:
2620                 /*
2621                  * Socket access is controlled by the socket
2622                  * structures associated with the task involved.
2623                  */
2624                 final = smack_known_star.smk_known;
2625                 break;
2626         case PROC_SUPER_MAGIC:
2627                 /*
2628                  * Casey says procfs appears not to care.
2629                  * The superblock default suffices.
2630                  */
2631                 break;
2632         case TMPFS_MAGIC:
2633                 /*
2634                  * Device labels should come from the filesystem,
2635                  * but watch out, because they're volitile,
2636                  * getting recreated on every reboot.
2637                  */
2638                 final = smack_known_star.smk_known;
2639                 /*
2640                  * No break.
2641                  *
2642                  * If a smack value has been set we want to use it,
2643                  * but since tmpfs isn't giving us the opportunity
2644                  * to set mount options simulate setting the
2645                  * superblock default.
2646                  */
2647         default:
2648                 /*
2649                  * This isn't an understood special case.
2650                  * Get the value from the xattr.
2651                  */
2652
2653                 /*
2654                  * UNIX domain sockets use lower level socket data.
2655                  */
2656                 if (S_ISSOCK(inode->i_mode)) {
2657                         final = smack_known_star.smk_known;
2658                         break;
2659                 }
2660                 /*
2661                  * No xattr support means, alas, no SMACK label.
2662                  * Use the aforeapplied default.
2663                  * It would be curious if the label of the task
2664                  * does not match that assigned.
2665                  */
2666                 if (inode->i_op->getxattr == NULL)
2667                         break;
2668                 /*
2669                  * Get the dentry for xattr.
2670                  */
2671                 dp = dget(opt_dentry);
2672                 fetched = smk_fetch(XATTR_NAME_SMACK, inode, dp);
2673                 if (fetched != NULL) {
2674                         final = fetched;
2675                         if (S_ISDIR(inode->i_mode)) {
2676                                 trattr[0] = '\0';
2677                                 inode->i_op->getxattr(dp,
2678                                         XATTR_NAME_SMACKTRANSMUTE,
2679                                         trattr, TRANS_TRUE_SIZE);
2680                                 if (strncmp(trattr, TRANS_TRUE,
2681                                             TRANS_TRUE_SIZE) == 0)
2682                                         transflag = SMK_INODE_TRANSMUTE;
2683                         }
2684                 }
2685                 isp->smk_task = smk_fetch(XATTR_NAME_SMACKEXEC, inode, dp);
2686                 isp->smk_mmap = smk_fetch(XATTR_NAME_SMACKMMAP, inode, dp);
2687
2688                 dput(dp);
2689                 break;
2690         }
2691
2692         if (final == NULL)
2693                 isp->smk_inode = csp;
2694         else
2695                 isp->smk_inode = final;
2696
2697         isp->smk_flags |= (SMK_INODE_INSTANT | transflag);
2698
2699 unlockandout:
2700         mutex_unlock(&isp->smk_lock);
2701         return;
2702 }
2703
2704 /**
2705  * smack_getprocattr - Smack process attribute access
2706  * @p: the object task
2707  * @name: the name of the attribute in /proc/.../attr
2708  * @value: where to put the result
2709  *
2710  * Places a copy of the task Smack into value
2711  *
2712  * Returns the length of the smack label or an error code
2713  */
2714 static int smack_getprocattr(struct task_struct *p, char *name, char **value)
2715 {
2716         char *cp;
2717         int slen;
2718
2719         if (strcmp(name, "current") != 0)
2720                 return -EINVAL;
2721
2722         cp = kstrdup(smk_of_task(task_security(p)), GFP_KERNEL);
2723         if (cp == NULL)
2724                 return -ENOMEM;
2725
2726         slen = strlen(cp);
2727         *value = cp;
2728         return slen;
2729 }
2730
2731 /**
2732  * smack_setprocattr - Smack process attribute setting
2733  * @p: the object task
2734  * @name: the name of the attribute in /proc/.../attr
2735  * @value: the value to set
2736  * @size: the size of the value
2737  *
2738  * Sets the Smack value of the task. Only setting self
2739  * is permitted and only with privilege
2740  *
2741  * Returns the length of the smack label or an error code
2742  */
2743 static int smack_setprocattr(struct task_struct *p, char *name,
2744                              void *value, size_t size)
2745 {
2746         int rc;
2747         struct task_smack *tsp;
2748         struct task_smack *oldtsp;
2749         struct cred *new;
2750         char *newsmack;
2751
2752         /*
2753          * Changing another process' Smack value is too dangerous
2754          * and supports no sane use case.
2755          */
2756         if (p != current)
2757                 return -EPERM;
2758
2759         if (!capable(CAP_MAC_ADMIN))
2760                 return -EPERM;
2761
2762         if (value == NULL || size == 0 || size >= SMK_LABELLEN)
2763                 return -EINVAL;
2764
2765         if (strcmp(name, "current") != 0)
2766                 return -EINVAL;
2767
2768         newsmack = smk_import(value, size);
2769         if (newsmack == NULL)
2770                 return -EINVAL;
2771
2772         /*
2773          * No process is ever allowed the web ("@") label.
2774          */
2775         if (newsmack == smack_known_web.smk_known)
2776                 return -EPERM;
2777
2778         oldtsp = p->cred->security;
2779         new = prepare_creds();
2780         if (new == NULL)
2781                 return -ENOMEM;
2782
2783         tsp = new_task_smack(newsmack, oldtsp->smk_forked, GFP_KERNEL);
2784         if (tsp == NULL) {
2785                 kfree(new);
2786                 return -ENOMEM;
2787         }
2788         rc = smk_copy_rules(&tsp->smk_rules, &oldtsp->smk_rules, GFP_KERNEL);
2789         if (rc != 0)
2790                 return rc;
2791
2792         new->security = tsp;
2793         commit_creds(new);
2794         return size;
2795 }
2796
2797 /**
2798  * smack_unix_stream_connect - Smack access on UDS
2799  * @sock: one sock
2800  * @other: the other sock
2801  * @newsk: unused
2802  *
2803  * Return 0 if a subject with the smack of sock could access
2804  * an object with the smack of other, otherwise an error code
2805  */
2806 static int smack_unix_stream_connect(struct sock *sock,
2807                                      struct sock *other, struct sock *newsk)
2808 {
2809         struct socket_smack *ssp = sock->sk_security;
2810         struct socket_smack *osp = other->sk_security;
2811         struct socket_smack *nsp = newsk->sk_security;
2812         struct smk_audit_info ad;
2813         int rc = 0;
2814
2815 #ifdef CONFIG_AUDIT
2816         struct lsm_network_audit net;
2817
2818         smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
2819         smk_ad_setfield_u_net_sk(&ad, other);
2820 #endif
2821
2822         if (!capable(CAP_MAC_OVERRIDE))
2823                 rc = smk_access(ssp->smk_out, osp->smk_in, MAY_WRITE, &ad);
2824
2825         /*
2826          * Cross reference the peer labels for SO_PEERSEC.
2827          */
2828         if (rc == 0) {
2829                 nsp->smk_packet = ssp->smk_out;
2830                 ssp->smk_packet = osp->smk_out;
2831         }
2832
2833         return rc;
2834 }
2835
2836 /**
2837  * smack_unix_may_send - Smack access on UDS
2838  * @sock: one socket
2839  * @other: the other socket
2840  *
2841  * Return 0 if a subject with the smack of sock could access
2842  * an object with the smack of other, otherwise an error code
2843  */
2844 static int smack_unix_may_send(struct socket *sock, struct socket *other)
2845 {
2846         struct socket_smack *ssp = sock->sk->sk_security;
2847         struct socket_smack *osp = other->sk->sk_security;
2848         struct smk_audit_info ad;
2849         int rc = 0;
2850
2851 #ifdef CONFIG_AUDIT
2852         struct lsm_network_audit net;
2853
2854         smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
2855         smk_ad_setfield_u_net_sk(&ad, other->sk);
2856 #endif
2857
2858         if (!capable(CAP_MAC_OVERRIDE))
2859                 rc = smk_access(ssp->smk_out, osp->smk_in, MAY_WRITE, &ad);
2860
2861         return rc;
2862 }
2863
2864 /**
2865  * smack_socket_sendmsg - Smack check based on destination host
2866  * @sock: the socket
2867  * @msg: the message
2868  * @size: the size of the message
2869  *
2870  * Return 0 if the current subject can write to the destination
2871  * host. This is only a question if the destination is a single
2872  * label host.
2873  */
2874 static int smack_socket_sendmsg(struct socket *sock, struct msghdr *msg,
2875                                 int size)
2876 {
2877         struct sockaddr_in *sip = (struct sockaddr_in *) msg->msg_name;
2878
2879         /*
2880          * Perfectly reasonable for this to be NULL
2881          */
2882         if (sip == NULL || sip->sin_family != AF_INET)
2883                 return 0;
2884
2885         return smack_netlabel_send(sock->sk, sip);
2886 }
2887
2888 /**
2889  * smack_from_secattr - Convert a netlabel attr.mls.lvl/attr.mls.cat pair to smack
2890  * @sap: netlabel secattr
2891  * @ssp: socket security information
2892  *
2893  * Returns a pointer to a Smack label found on the label list.
2894  */
2895 static char *smack_from_secattr(struct netlbl_lsm_secattr *sap,
2896                                 struct socket_smack *ssp)
2897 {
2898         struct smack_known *skp;
2899         char smack[SMK_LABELLEN];
2900         char *sp;
2901         int pcat;
2902
2903         if ((sap->flags & NETLBL_SECATTR_MLS_LVL) != 0) {
2904                 /*
2905                  * Looks like a CIPSO packet.
2906                  * If there are flags but no level netlabel isn't
2907                  * behaving the way we expect it to.
2908                  *
2909                  * Get the categories, if any
2910                  * Without guidance regarding the smack value
2911                  * for the packet fall back on the network
2912                  * ambient value.
2913                  */
2914                 memset(smack, '\0', SMK_LABELLEN);
2915                 if ((sap->flags & NETLBL_SECATTR_MLS_CAT) != 0)
2916                         for (pcat = -1;;) {
2917                                 pcat = netlbl_secattr_catmap_walk(
2918                                         sap->attr.mls.cat, pcat + 1);
2919                                 if (pcat < 0)
2920                                         break;
2921                                 smack_catset_bit(pcat, smack);
2922                         }
2923                 /*
2924                  * If it is CIPSO using smack direct mapping
2925                  * we are already done. WeeHee.
2926                  */
2927                 if (sap->attr.mls.lvl == smack_cipso_direct) {
2928                         /*
2929                          * The label sent is usually on the label list.
2930                          *
2931                          * If it is not we may still want to allow the
2932                          * delivery.
2933                          *
2934                          * If the recipient is accepting all packets
2935                          * because it is using the star ("*") label
2936                          * for SMACK64IPIN provide the web ("@") label
2937                          * so that a directed response will succeed.
2938                          * This is not very correct from a MAC point
2939                          * of view, but gets around the problem that
2940                          * locking prevents adding the newly discovered
2941                          * label to the list.
2942                          * The case where the recipient is not using
2943                          * the star label should obviously fail.
2944                          * The easy way to do this is to provide the
2945                          * star label as the subject label.
2946                          */
2947                         skp = smk_find_entry(smack);
2948                         if (skp != NULL)
2949                                 return skp->smk_known;
2950                         if (ssp != NULL &&
2951                             ssp->smk_in == smack_known_star.smk_known)
2952                                 return smack_known_web.smk_known;
2953                         return smack_known_star.smk_known;
2954                 }
2955                 /*
2956                  * Look it up in the supplied table if it is not
2957                  * a direct mapping.
2958                  */
2959                 sp = smack_from_cipso(sap->attr.mls.lvl, smack);
2960                 if (sp != NULL)
2961                         return sp;
2962                 if (ssp != NULL && ssp->smk_in == smack_known_star.smk_known)
2963                         return smack_known_web.smk_known;
2964                 return smack_known_star.smk_known;
2965         }
2966         if ((sap->flags & NETLBL_SECATTR_SECID) != 0) {
2967                 /*
2968                  * Looks like a fallback, which gives us a secid.
2969                  */
2970                 sp = smack_from_secid(sap->attr.secid);
2971                 /*
2972                  * This has got to be a bug because it is
2973                  * impossible to specify a fallback without
2974                  * specifying the label, which will ensure
2975                  * it has a secid, and the only way to get a
2976                  * secid is from a fallback.
2977                  */
2978                 BUG_ON(sp == NULL);
2979                 return sp;
2980         }
2981         /*
2982          * Without guidance regarding the smack value
2983          * for the packet fall back on the network
2984          * ambient value.
2985          */
2986         return smack_net_ambient;
2987 }
2988
2989 /**
2990  * smack_socket_sock_rcv_skb - Smack packet delivery access check
2991  * @sk: socket
2992  * @skb: packet
2993  *
2994  * Returns 0 if the packet should be delivered, an error code otherwise
2995  */
2996 static int smack_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
2997 {
2998         struct netlbl_lsm_secattr secattr;
2999         struct socket_smack *ssp = sk->sk_security;
3000         char *csp;
3001         int rc;
3002         struct smk_audit_info ad;
3003 #ifdef CONFIG_AUDIT
3004         struct lsm_network_audit net;
3005 #endif
3006         if (sk->sk_family != PF_INET && sk->sk_family != PF_INET6)
3007                 return 0;
3008
3009         /*
3010          * Translate what netlabel gave us.
3011          */
3012         netlbl_secattr_init(&secattr);
3013
3014         rc = netlbl_skbuff_getattr(skb, sk->sk_family, &secattr);
3015         if (rc == 0)
3016                 csp = smack_from_secattr(&secattr, ssp);
3017         else
3018                 csp = smack_net_ambient;
3019
3020         netlbl_secattr_destroy(&secattr);
3021
3022 #ifdef CONFIG_AUDIT
3023         smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
3024         ad.a.u.net->family = sk->sk_family;
3025         ad.a.u.net->netif = skb->skb_iif;
3026         ipv4_skb_to_auditdata(skb, &ad.a, NULL);
3027 #endif
3028         /*
3029          * Receiving a packet requires that the other end
3030          * be able to write here. Read access is not required.
3031          * This is the simplist possible security model
3032          * for networking.
3033          */
3034         rc = smk_access(csp, ssp->smk_in, MAY_WRITE, &ad);
3035         if (rc != 0)
3036                 netlbl_skbuff_err(skb, rc, 0);
3037         return rc;
3038 }
3039
3040 /**
3041  * smack_socket_getpeersec_stream - pull in packet label
3042  * @sock: the socket
3043  * @optval: user's destination
3044  * @optlen: size thereof
3045  * @len: max thereof
3046  *
3047  * returns zero on success, an error code otherwise
3048  */
3049 static int smack_socket_getpeersec_stream(struct socket *sock,
3050                                           char __user *optval,
3051                                           int __user *optlen, unsigned len)
3052 {
3053         struct socket_smack *ssp;
3054         char *rcp = "";
3055         int slen = 1;
3056         int rc = 0;
3057
3058         ssp = sock->sk->sk_security;
3059         if (ssp->smk_packet != NULL) {
3060                 rcp = ssp->smk_packet;
3061                 slen = strlen(rcp) + 1;
3062         }
3063
3064         if (slen > len)
3065                 rc = -ERANGE;
3066         else if (copy_to_user(optval, rcp, slen) != 0)
3067                 rc = -EFAULT;
3068
3069         if (put_user(slen, optlen) != 0)
3070                 rc = -EFAULT;
3071
3072         return rc;
3073 }
3074
3075
3076 /**
3077  * smack_socket_getpeersec_dgram - pull in packet label
3078  * @sock: the peer socket
3079  * @skb: packet data
3080  * @secid: pointer to where to put the secid of the packet
3081  *
3082  * Sets the netlabel socket state on sk from parent
3083  */
3084 static int smack_socket_getpeersec_dgram(struct socket *sock,
3085                                          struct sk_buff *skb, u32 *secid)
3086
3087 {
3088         struct netlbl_lsm_secattr secattr;
3089         struct socket_smack *ssp = NULL;
3090         char *sp;
3091         int family = PF_UNSPEC;
3092         u32 s = 0;      /* 0 is the invalid secid */
3093         int rc;
3094
3095         if (skb != NULL) {
3096                 if (skb->protocol == htons(ETH_P_IP))
3097                         family = PF_INET;
3098                 else if (skb->protocol == htons(ETH_P_IPV6))
3099                         family = PF_INET6;
3100         }
3101         if (family == PF_UNSPEC && sock != NULL)
3102                 family = sock->sk->sk_family;
3103
3104         if (family == PF_UNIX) {
3105                 ssp = sock->sk->sk_security;
3106                 s = smack_to_secid(ssp->smk_out);
3107         } else if (family == PF_INET || family == PF_INET6) {
3108                 /*
3109                  * Translate what netlabel gave us.
3110                  */
3111                 if (sock != NULL && sock->sk != NULL)
3112                         ssp = sock->sk->sk_security;
3113                 netlbl_secattr_init(&secattr);
3114                 rc = netlbl_skbuff_getattr(skb, family, &secattr);
3115                 if (rc == 0) {
3116                         sp = smack_from_secattr(&secattr, ssp);
3117                         s = smack_to_secid(sp);
3118                 }
3119                 netlbl_secattr_destroy(&secattr);
3120         }
3121         *secid = s;
3122         if (s == 0)
3123                 return -EINVAL;
3124         return 0;
3125 }
3126
3127 /**
3128  * smack_sock_graft - Initialize a newly created socket with an existing sock
3129  * @sk: child sock
3130  * @parent: parent socket
3131  *
3132  * Set the smk_{in,out} state of an existing sock based on the process that
3133  * is creating the new socket.
3134  */
3135 static void smack_sock_graft(struct sock *sk, struct socket *parent)
3136 {
3137         struct socket_smack *ssp;
3138
3139         if (sk == NULL ||
3140             (sk->sk_family != PF_INET && sk->sk_family != PF_INET6))
3141                 return;
3142
3143         ssp = sk->sk_security;
3144         ssp->smk_in = ssp->smk_out = smk_of_current();
3145         /* cssp->smk_packet is already set in smack_inet_csk_clone() */
3146 }
3147
3148 /**
3149  * smack_inet_conn_request - Smack access check on connect
3150  * @sk: socket involved
3151  * @skb: packet
3152  * @req: unused
3153  *
3154  * Returns 0 if a task with the packet label could write to
3155  * the socket, otherwise an error code
3156  */
3157 static int smack_inet_conn_request(struct sock *sk, struct sk_buff *skb,
3158                                    struct request_sock *req)
3159 {
3160         u16 family = sk->sk_family;
3161         struct socket_smack *ssp = sk->sk_security;
3162         struct netlbl_lsm_secattr secattr;
3163         struct sockaddr_in addr;
3164         struct iphdr *hdr;
3165         char *sp;
3166         int rc;
3167         struct smk_audit_info ad;
3168 #ifdef CONFIG_AUDIT
3169         struct lsm_network_audit net;
3170 #endif
3171
3172         /* handle mapped IPv4 packets arriving via IPv6 sockets */
3173         if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
3174                 family = PF_INET;
3175
3176         netlbl_secattr_init(&secattr);
3177         rc = netlbl_skbuff_getattr(skb, family, &secattr);
3178         if (rc == 0)
3179                 sp = smack_from_secattr(&secattr, ssp);
3180         else
3181                 sp = smack_known_huh.smk_known;
3182         netlbl_secattr_destroy(&secattr);
3183
3184 #ifdef CONFIG_AUDIT
3185         smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
3186         ad.a.u.net->family = family;
3187         ad.a.u.net->netif = skb->skb_iif;
3188         ipv4_skb_to_auditdata(skb, &ad.a, NULL);
3189 #endif
3190         /*
3191          * Receiving a packet requires that the other end be able to write
3192          * here. Read access is not required.
3193          */
3194         rc = smk_access(sp, ssp->smk_in, MAY_WRITE, &ad);
3195         if (rc != 0)
3196                 return rc;
3197
3198         /*
3199          * Save the peer's label in the request_sock so we can later setup
3200          * smk_packet in the child socket so that SO_PEERCRED can report it.
3201          */
3202         req->peer_secid = smack_to_secid(sp);
3203
3204         /*
3205          * We need to decide if we want to label the incoming connection here
3206          * if we do we only need to label the request_sock and the stack will
3207          * propagate the wire-label to the sock when it is created.
3208          */
3209         hdr = ip_hdr(skb);
3210         addr.sin_addr.s_addr = hdr->saddr;
3211         rcu_read_lock();
3212         if (smack_host_label(&addr) == NULL) {
3213                 rcu_read_unlock();
3214                 netlbl_secattr_init(&secattr);
3215                 smack_to_secattr(sp, &secattr);
3216                 rc = netlbl_req_setattr(req, &secattr);
3217                 netlbl_secattr_destroy(&secattr);
3218         } else {
3219                 rcu_read_unlock();
3220                 netlbl_req_delattr(req);
3221         }
3222
3223         return rc;
3224 }
3225
3226 /**
3227  * smack_inet_csk_clone - Copy the connection information to the new socket
3228  * @sk: the new socket
3229  * @req: the connection's request_sock
3230  *
3231  * Transfer the connection's peer label to the newly created socket.
3232  */
3233 static void smack_inet_csk_clone(struct sock *sk,
3234                                  const struct request_sock *req)
3235 {
3236         struct socket_smack *ssp = sk->sk_security;
3237
3238         if (req->peer_secid != 0)
3239                 ssp->smk_packet = smack_from_secid(req->peer_secid);
3240         else
3241                 ssp->smk_packet = NULL;
3242 }
3243
3244 /*
3245  * Key management security hooks
3246  *
3247  * Casey has not tested key support very heavily.
3248  * The permission check is most likely too restrictive.
3249  * If you care about keys please have a look.
3250  */
3251 #ifdef CONFIG_KEYS
3252
3253 /**
3254  * smack_key_alloc - Set the key security blob
3255  * @key: object
3256  * @cred: the credentials to use
3257  * @flags: unused
3258  *
3259  * No allocation required
3260  *
3261  * Returns 0
3262  */
3263 static int smack_key_alloc(struct key *key, const struct cred *cred,
3264                            unsigned long flags)
3265 {
3266         key->security = smk_of_task(cred->security);
3267         return 0;
3268 }
3269
3270 /**
3271  * smack_key_free - Clear the key security blob
3272  * @key: the object
3273  *
3274  * Clear the blob pointer
3275  */
3276 static void smack_key_free(struct key *key)
3277 {
3278         key->security = NULL;
3279 }
3280
3281 /*
3282  * smack_key_permission - Smack access on a key
3283  * @key_ref: gets to the object
3284  * @cred: the credentials to use
3285  * @perm: unused
3286  *
3287  * Return 0 if the task has read and write to the object,
3288  * an error code otherwise
3289  */
3290 static int smack_key_permission(key_ref_t key_ref,
3291                                 const struct cred *cred, key_perm_t perm)
3292 {
3293         struct key *keyp;
3294         struct smk_audit_info ad;
3295         char *tsp = smk_of_task(cred->security);
3296
3297         keyp = key_ref_to_ptr(key_ref);
3298         if (keyp == NULL)
3299                 return -EINVAL;
3300         /*
3301          * If the key hasn't been initialized give it access so that
3302          * it may do so.
3303          */
3304         if (keyp->security == NULL)
3305                 return 0;
3306         /*
3307          * This should not occur
3308          */
3309         if (tsp == NULL)
3310                 return -EACCES;
3311 #ifdef CONFIG_AUDIT
3312         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_KEY);
3313         ad.a.u.key_struct.key = keyp->serial;
3314         ad.a.u.key_struct.key_desc = keyp->description;
3315 #endif
3316         return smk_access(tsp, keyp->security,
3317                                  MAY_READWRITE, &ad);
3318 }
3319 #endif /* CONFIG_KEYS */
3320
3321 /*
3322  * Smack Audit hooks
3323  *
3324  * Audit requires a unique representation of each Smack specific
3325  * rule. This unique representation is used to distinguish the
3326  * object to be audited from remaining kernel objects and also
3327  * works as a glue between the audit hooks.
3328  *
3329  * Since repository entries are added but never deleted, we'll use
3330  * the smack_known label address related to the given audit rule as
3331  * the needed unique representation. This also better fits the smack
3332  * model where nearly everything is a label.
3333  */
3334 #ifdef CONFIG_AUDIT
3335
3336 /**
3337  * smack_audit_rule_init - Initialize a smack audit rule
3338  * @field: audit rule fields given from user-space (audit.h)
3339  * @op: required testing operator (=, !=, >, <, ...)
3340  * @rulestr: smack label to be audited
3341  * @vrule: pointer to save our own audit rule representation
3342  *
3343  * Prepare to audit cases where (@field @op @rulestr) is true.
3344  * The label to be audited is created if necessay.
3345  */
3346 static int smack_audit_rule_init(u32 field, u32 op, char *rulestr, void **vrule)
3347 {
3348         char **rule = (char **)vrule;
3349         *rule = NULL;
3350
3351         if (field != AUDIT_SUBJ_USER && field != AUDIT_OBJ_USER)
3352                 return -EINVAL;
3353
3354         if (op != Audit_equal && op != Audit_not_equal)
3355                 return -EINVAL;
3356
3357         *rule = smk_import(rulestr, 0);
3358
3359         return 0;
3360 }
3361
3362 /**
3363  * smack_audit_rule_known - Distinguish Smack audit rules
3364  * @krule: rule of interest, in Audit kernel representation format
3365  *
3366  * This is used to filter Smack rules from remaining Audit ones.
3367  * If it's proved that this rule belongs to us, the
3368  * audit_rule_match hook will be called to do the final judgement.
3369  */
3370 static int smack_audit_rule_known(struct audit_krule *krule)
3371 {
3372         struct audit_field *f;
3373         int i;
3374
3375         for (i = 0; i < krule->field_count; i++) {
3376                 f = &krule->fields[i];
3377
3378                 if (f->type == AUDIT_SUBJ_USER || f->type == AUDIT_OBJ_USER)
3379                         return 1;
3380         }
3381
3382         return 0;
3383 }
3384
3385 /**
3386  * smack_audit_rule_match - Audit given object ?
3387  * @secid: security id for identifying the object to test
3388  * @field: audit rule flags given from user-space
3389  * @op: required testing operator
3390  * @vrule: smack internal rule presentation
3391  * @actx: audit context associated with the check
3392  *
3393  * The core Audit hook. It's used to take the decision of
3394  * whether to audit or not to audit a given object.
3395  */
3396 static int smack_audit_rule_match(u32 secid, u32 field, u32 op, void *vrule,
3397                                   struct audit_context *actx)
3398 {
3399         char *smack;
3400         char *rule = vrule;
3401
3402         if (!rule) {
3403                 audit_log(actx, GFP_KERNEL, AUDIT_SELINUX_ERR,
3404                           "Smack: missing rule\n");
3405                 return -ENOENT;
3406         }
3407
3408         if (field != AUDIT_SUBJ_USER && field != AUDIT_OBJ_USER)
3409                 return 0;
3410
3411         smack = smack_from_secid(secid);
3412
3413         /*
3414          * No need to do string comparisons. If a match occurs,
3415          * both pointers will point to the same smack_known
3416          * label.
3417          */
3418         if (op == Audit_equal)
3419                 return (rule == smack);
3420         if (op == Audit_not_equal)
3421                 return (rule != smack);
3422
3423         return 0;
3424 }
3425
3426 /**
3427  * smack_audit_rule_free - free smack rule representation
3428  * @vrule: rule to be freed.
3429  *
3430  * No memory was allocated.
3431  */
3432 static void smack_audit_rule_free(void *vrule)
3433 {
3434         /* No-op */
3435 }
3436
3437 #endif /* CONFIG_AUDIT */
3438
3439 /**
3440  * smack_secid_to_secctx - return the smack label for a secid
3441  * @secid: incoming integer
3442  * @secdata: destination
3443  * @seclen: how long it is
3444  *
3445  * Exists for networking code.
3446  */
3447 static int smack_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
3448 {
3449         char *sp = smack_from_secid(secid);
3450
3451         if (secdata)
3452                 *secdata = sp;
3453         *seclen = strlen(sp);
3454         return 0;
3455 }
3456
3457 /**
3458  * smack_secctx_to_secid - return the secid for a smack label
3459  * @secdata: smack label
3460  * @seclen: how long result is
3461  * @secid: outgoing integer
3462  *
3463  * Exists for audit and networking code.
3464  */
3465 static int smack_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid)
3466 {
3467         *secid = smack_to_secid(secdata);
3468         return 0;
3469 }
3470
3471 /**
3472  * smack_release_secctx - don't do anything.
3473  * @secdata: unused
3474  * @seclen: unused
3475  *
3476  * Exists to make sure nothing gets done, and properly
3477  */
3478 static void smack_release_secctx(char *secdata, u32 seclen)
3479 {
3480 }
3481
3482 static int smack_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen)
3483 {
3484         return smack_inode_setsecurity(inode, XATTR_SMACK_SUFFIX, ctx, ctxlen, 0);
3485 }
3486
3487 static int smack_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen)
3488 {
3489         return __vfs_setxattr_noperm(dentry, XATTR_NAME_SMACK, ctx, ctxlen, 0);
3490 }
3491
3492 static int smack_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen)
3493 {
3494         int len = 0;
3495         len = smack_inode_getsecurity(inode, XATTR_SMACK_SUFFIX, ctx, true);
3496
3497         if (len < 0)
3498                 return len;
3499         *ctxlen = len;
3500         return 0;
3501 }
3502
3503 struct security_operations smack_ops = {
3504         .name =                         "smack",
3505
3506         .ptrace_access_check =          smack_ptrace_access_check,
3507         .ptrace_traceme =               smack_ptrace_traceme,
3508         .syslog =                       smack_syslog,
3509
3510         .sb_alloc_security =            smack_sb_alloc_security,
3511         .sb_free_security =             smack_sb_free_security,
3512         .sb_copy_data =                 smack_sb_copy_data,
3513         .sb_kern_mount =                smack_sb_kern_mount,
3514         .sb_statfs =                    smack_sb_statfs,
3515         .sb_mount =                     smack_sb_mount,
3516         .sb_umount =                    smack_sb_umount,
3517
3518         .bprm_set_creds =               smack_bprm_set_creds,
3519         .bprm_committing_creds =        smack_bprm_committing_creds,
3520         .bprm_secureexec =              smack_bprm_secureexec,
3521
3522         .inode_alloc_security =         smack_inode_alloc_security,
3523         .inode_free_security =          smack_inode_free_security,
3524         .inode_init_security =          smack_inode_init_security,
3525         .inode_link =                   smack_inode_link,
3526         .inode_unlink =                 smack_inode_unlink,
3527         .inode_rmdir =                  smack_inode_rmdir,
3528         .inode_rename =                 smack_inode_rename,
3529         .inode_permission =             smack_inode_permission,
3530         .inode_setattr =                smack_inode_setattr,
3531         .inode_getattr =                smack_inode_getattr,
3532         .inode_setxattr =               smack_inode_setxattr,
3533         .inode_post_setxattr =          smack_inode_post_setxattr,
3534         .inode_getxattr =               smack_inode_getxattr,
3535         .inode_removexattr =            smack_inode_removexattr,
3536         .inode_getsecurity =            smack_inode_getsecurity,
3537         .inode_setsecurity =            smack_inode_setsecurity,
3538         .inode_listsecurity =           smack_inode_listsecurity,
3539         .inode_getsecid =               smack_inode_getsecid,
3540
3541         .file_permission =              smack_file_permission,
3542         .file_alloc_security =          smack_file_alloc_security,
3543         .file_free_security =           smack_file_free_security,
3544         .file_ioctl =                   smack_file_ioctl,
3545         .file_lock =                    smack_file_lock,
3546         .file_fcntl =                   smack_file_fcntl,
3547         .file_mmap =                    smack_file_mmap,
3548         .file_set_fowner =              smack_file_set_fowner,
3549         .file_send_sigiotask =          smack_file_send_sigiotask,
3550         .file_receive =                 smack_file_receive,
3551
3552         .dentry_open =                  smack_dentry_open,
3553
3554         .cred_alloc_blank =             smack_cred_alloc_blank,
3555         .cred_free =                    smack_cred_free,
3556         .cred_prepare =                 smack_cred_prepare,
3557         .cred_transfer =                smack_cred_transfer,
3558         .kernel_act_as =                smack_kernel_act_as,
3559         .kernel_create_files_as =       smack_kernel_create_files_as,
3560         .task_setpgid =                 smack_task_setpgid,
3561         .task_getpgid =                 smack_task_getpgid,
3562         .task_getsid =                  smack_task_getsid,
3563         .task_getsecid =                smack_task_getsecid,
3564         .task_setnice =                 smack_task_setnice,
3565         .task_setioprio =               smack_task_setioprio,
3566         .task_getioprio =               smack_task_getioprio,
3567         .task_setscheduler =            smack_task_setscheduler,
3568         .task_getscheduler =            smack_task_getscheduler,
3569         .task_movememory =              smack_task_movememory,
3570         .task_kill =                    smack_task_kill,
3571         .task_wait =                    smack_task_wait,
3572         .task_to_inode =                smack_task_to_inode,
3573
3574         .ipc_permission =               smack_ipc_permission,
3575         .ipc_getsecid =                 smack_ipc_getsecid,
3576
3577         .msg_msg_alloc_security =       smack_msg_msg_alloc_security,
3578         .msg_msg_free_security =        smack_msg_msg_free_security,
3579
3580         .msg_queue_alloc_security =     smack_msg_queue_alloc_security,
3581         .msg_queue_free_security =      smack_msg_queue_free_security,
3582         .msg_queue_associate =          smack_msg_queue_associate,
3583         .msg_queue_msgctl =             smack_msg_queue_msgctl,
3584         .msg_queue_msgsnd =             smack_msg_queue_msgsnd,
3585         .msg_queue_msgrcv =             smack_msg_queue_msgrcv,
3586
3587         .shm_alloc_security =           smack_shm_alloc_security,
3588         .shm_free_security =            smack_shm_free_security,
3589         .shm_associate =                smack_shm_associate,
3590         .shm_shmctl =                   smack_shm_shmctl,
3591         .shm_shmat =                    smack_shm_shmat,
3592
3593         .sem_alloc_security =           smack_sem_alloc_security,
3594         .sem_free_security =            smack_sem_free_security,
3595         .sem_associate =                smack_sem_associate,
3596         .sem_semctl =                   smack_sem_semctl,
3597         .sem_semop =                    smack_sem_semop,
3598
3599         .d_instantiate =                smack_d_instantiate,
3600
3601         .getprocattr =                  smack_getprocattr,
3602         .setprocattr =                  smack_setprocattr,
3603
3604         .unix_stream_connect =          smack_unix_stream_connect,
3605         .unix_may_send =                smack_unix_may_send,
3606
3607         .socket_post_create =           smack_socket_post_create,
3608         .socket_connect =               smack_socket_connect,
3609         .socket_sendmsg =               smack_socket_sendmsg,
3610         .socket_sock_rcv_skb =          smack_socket_sock_rcv_skb,
3611         .socket_getpeersec_stream =     smack_socket_getpeersec_stream,
3612         .socket_getpeersec_dgram =      smack_socket_getpeersec_dgram,
3613         .sk_alloc_security =            smack_sk_alloc_security,
3614         .sk_free_security =             smack_sk_free_security,
3615         .sock_graft =                   smack_sock_graft,
3616         .inet_conn_request =            smack_inet_conn_request,
3617         .inet_csk_clone =               smack_inet_csk_clone,
3618
3619  /* key management security hooks */
3620 #ifdef CONFIG_KEYS
3621         .key_alloc =                    smack_key_alloc,
3622         .key_free =                     smack_key_free,
3623         .key_permission =               smack_key_permission,
3624 #endif /* CONFIG_KEYS */
3625
3626  /* Audit hooks */
3627 #ifdef CONFIG_AUDIT
3628         .audit_rule_init =              smack_audit_rule_init,
3629         .audit_rule_known =             smack_audit_rule_known,
3630         .audit_rule_match =             smack_audit_rule_match,
3631         .audit_rule_free =              smack_audit_rule_free,
3632 #endif /* CONFIG_AUDIT */
3633
3634         .secid_to_secctx =              smack_secid_to_secctx,
3635         .secctx_to_secid =              smack_secctx_to_secid,
3636         .release_secctx =               smack_release_secctx,
3637         .inode_notifysecctx =           smack_inode_notifysecctx,
3638         .inode_setsecctx =              smack_inode_setsecctx,
3639         .inode_getsecctx =              smack_inode_getsecctx,
3640 };
3641
3642
3643 static __init void init_smack_know_list(void)
3644 {
3645         list_add(&smack_known_huh.list, &smack_known_list);
3646         list_add(&smack_known_hat.list, &smack_known_list);
3647         list_add(&smack_known_star.list, &smack_known_list);
3648         list_add(&smack_known_floor.list, &smack_known_list);
3649         list_add(&smack_known_invalid.list, &smack_known_list);
3650         list_add(&smack_known_web.list, &smack_known_list);
3651 }
3652
3653 /**
3654  * smack_init - initialize the smack system
3655  *
3656  * Returns 0
3657  */
3658 static __init int smack_init(void)
3659 {
3660         struct cred *cred;
3661         struct task_smack *tsp;
3662
3663         if (!security_module_enable(&smack_ops))
3664                 return 0;
3665
3666         tsp = new_task_smack(smack_known_floor.smk_known,
3667                                 smack_known_floor.smk_known, GFP_KERNEL);
3668         if (tsp == NULL)
3669                 return -ENOMEM;
3670
3671         printk(KERN_INFO "Smack:  Initializing.\n");
3672
3673         /*
3674          * Set the security state for the initial task.
3675          */
3676         cred = (struct cred *) current->cred;
3677         cred->security = tsp;
3678
3679         /* initialize the smack_know_list */
3680         init_smack_know_list();
3681         /*
3682          * Initialize locks
3683          */
3684         spin_lock_init(&smack_known_huh.smk_cipsolock);
3685         spin_lock_init(&smack_known_hat.smk_cipsolock);
3686         spin_lock_init(&smack_known_star.smk_cipsolock);
3687         spin_lock_init(&smack_known_floor.smk_cipsolock);
3688         spin_lock_init(&smack_known_invalid.smk_cipsolock);
3689
3690         /*
3691          * Register with LSM
3692          */
3693         if (register_security(&smack_ops))
3694                 panic("smack: Unable to register with kernel.\n");
3695
3696         return 0;
3697 }
3698
3699 /*
3700  * Smack requires early initialization in order to label
3701  * all processes and objects when they are created.
3702  */
3703 security_initcall(smack_init);