security/smack/smackfs.c

   1 /*
   2  * Copyright (C) 2007 Casey Schaufler <casey@schaufler-ca.com>
   3  *
   4  *      This program is free software; you can redistribute it and/or modify
   5  *      it under the terms of the GNU General Public License as published by
   6  *      the Free Software Foundation, version 2.
   7  *
   8  * Authors:
   9  *      Casey Schaufler <casey@schaufler-ca.com>
  10  *      Ahmed S. Darwish <darwish.07@gmail.com>
  11  *
  12  * Special thanks to the authors of selinuxfs.
  13  *
  14  *      Karl MacMillan <kmacmillan@tresys.com>
  15  *      James Morris <jmorris@redhat.com>
  16  *
  17  */
  18
  19 #include <linux/kernel.h>
  20 #include <linux/vmalloc.h>
  21 #include <linux/security.h>
  22 #include <linux/mutex.h>
  23 #include <net/netlabel.h>
  24 #include <net/cipso_ipv4.h>
  25 #include <linux/seq_file.h>
  26 #include <linux/ctype.h>
  27 #include "smack.h"
  28
  29 /*
  30  * smackfs pseudo filesystem.
  31  */
  32
  33 enum smk_inos {
  34         SMK_ROOT_INO    = 2,
  35         SMK_LOAD        = 3,    /* load policy */
  36         SMK_CIPSO       = 4,    /* load label -> CIPSO mapping */
  37         SMK_DOI         = 5,    /* CIPSO DOI */
  38         SMK_DIRECT      = 6,    /* CIPSO level indicating direct label */
  39         SMK_AMBIENT     = 7,    /* internet ambient label */
  40         SMK_NLTYPE      = 8,    /* label scheme to use by default */
  41 };
  42
  43 /*
  44  * List locks
  45  */
  46 static DEFINE_MUTEX(smack_list_lock);
  47 static DEFINE_MUTEX(smack_cipso_lock);
  48
  49 /*
  50  * This is the "ambient" label for network traffic.
  51  * If it isn't somehow marked, use this.
  52  * It can be reset via smackfs/ambient
  53  */
  54 char *smack_net_ambient = smack_known_floor.smk_known;
  55
  56 /*
  57  * This is the default packet marking scheme for network traffic.
  58  * It can be reset via smackfs/nltype
  59  */
  60 int smack_net_nltype = NETLBL_NLTYPE_CIPSOV4;
  61
  62 /*
  63  * This is the level in a CIPSO header that indicates a
  64  * smack label is contained directly in the category set.
  65  * It can be reset via smackfs/direct
  66  */
  67 int smack_cipso_direct = SMACK_CIPSO_DIRECT_DEFAULT;
  68
  69 static int smk_cipso_doi_value = SMACK_CIPSO_DOI_DEFAULT;
  70 struct smk_list_entry *smack_list;
  71
  72 #define SEQ_READ_FINISHED       1
  73
  74 /*
  75  * Disable concurrent writing open() operations
  76  */
  77 static struct semaphore smack_write_sem;
  78
  79 /*
  80  * Values for parsing cipso rules
  81  * SMK_DIGITLEN: Length of a digit field in a rule.
  82  * SMK_CIPSOMEN: Minimum possible cipso rule length.
  83  */
  84 #define SMK_DIGITLEN 4
  85 #define SMK_CIPSOMIN (SMK_MAXLEN + 2 * SMK_DIGITLEN)
  86
  87 /*
  88  * Seq_file read operations for /smack/load
  89  */
  90
  91 static void *load_seq_start(struct seq_file *s, loff_t *pos)
  92 {
  93         if (*pos == SEQ_READ_FINISHED)
  94                 return NULL;
  95
  96         return smack_list;
  97 }
  98
  99 static void *load_seq_next(struct seq_file *s, void *v, loff_t *pos)
 100 {
 101         struct smk_list_entry *skp = ((struct smk_list_entry *) v)->smk_next;
 102
 103         if (skp == NULL)
 104                 *pos = SEQ_READ_FINISHED;
 105
 106         return skp;
 107 }
 108
 109 static int load_seq_show(struct seq_file *s, void *v)
 110 {
 111         struct smk_list_entry *slp = (struct smk_list_entry *) v;
 112         struct smack_rule *srp = &slp->smk_rule;
 113
 114         seq_printf(s, "%s %s", (char *)srp->smk_subject,
 115                    (char *)srp->smk_object);
 116
 117         seq_putc(s, ' ');
 118
 119         if (srp->smk_access & MAY_READ)
 120                 seq_putc(s, 'r');
 121         if (srp->smk_access & MAY_WRITE)
 122                 seq_putc(s, 'w');
 123         if (srp->smk_access & MAY_EXEC)
 124                 seq_putc(s, 'x');
 125         if (srp->smk_access & MAY_APPEND)
 126                 seq_putc(s, 'a');
 127         if (srp->smk_access == 0)
 128                 seq_putc(s, '-');
 129
 130         seq_putc(s, '\n');
 131
 132         return 0;
 133 }
 134
 135 static void load_seq_stop(struct seq_file *s, void *v)
 136 {
 137         /* No-op */
 138 }
 139
 140 static struct seq_operations load_seq_ops = {
 141         .start = load_seq_start,
 142         .next  = load_seq_next,
 143         .show  = load_seq_show,
 144         .stop  = load_seq_stop,
 145 };
 146
 147 /**
 148  * smk_open_load - open() for /smack/load
 149  * @inode: inode structure representing file
 150  * @file: "load" file pointer
 151  *
 152  * For reading, use load_seq_* seq_file reading operations.
 153  */
 154 static int smk_open_load(struct inode *inode, struct file *file)
 155 {
 156         if ((file->f_flags & O_ACCMODE) == O_RDONLY)
 157                 return seq_open(file, &load_seq_ops);
 158
 159         if (down_interruptible(&smack_write_sem))
 160                 return -ERESTARTSYS;
 161
 162         return 0;
 163 }
 164
 165 /**
 166  * smk_release_load - release() for /smack/load
 167  * @inode: inode structure representing file
 168  * @file: "load" file pointer
 169  *
 170  * For a reading session, use the seq_file release
 171  * implementation.
 172  * Otherwise, we are at the end of a writing session so
 173  * clean everything up.
 174  */
 175 static int smk_release_load(struct inode *inode, struct file *file)
 176 {
 177         if ((file->f_flags & O_ACCMODE) == O_RDONLY)
 178                 return seq_release(inode, file);
 179
 180         up(&smack_write_sem);
 181         return 0;
 182 }
 183
 184 /**
 185  * smk_set_access - add a rule to the rule list
 186  * @srp: the new rule to add
 187  *
 188  * Looks through the current subject/object/access list for
 189  * the subject/object pair and replaces the access that was
 190  * there. If the pair isn't found add it with the specified
 191  * access.
 192  */
 193 static void smk_set_access(struct smack_rule *srp)
 194 {
 195         struct smk_list_entry *sp;
 196         struct smk_list_entry *newp;
 197
 198         mutex_lock(&smack_list_lock);
 199
 200         for (sp = smack_list; sp != NULL; sp = sp->smk_next)
 201                 if (sp->smk_rule.smk_subject == srp->smk_subject &&
 202                     sp->smk_rule.smk_object == srp->smk_object) {
 203                         sp->smk_rule.smk_access = srp->smk_access;
 204                         break;
 205                 }
 206
 207         if (sp == NULL) {
 208                 newp = kzalloc(sizeof(struct smk_list_entry), GFP_KERNEL);
 209                 newp->smk_rule = *srp;
 210                 newp->smk_next = smack_list;
 211                 smack_list = newp;
 212         }
 213
 214         mutex_unlock(&smack_list_lock);
 215
 216         return;
 217 }
 218
 219 /**
 220  * smk_write_load - write() for /smack/load
 221  * @filp: file pointer, not actually used
 222  * @buf: where to get the data from
 223  * @count: bytes sent
 224  * @ppos: where to start - must be 0
 225  *
 226  * Get one smack access rule from above.
 227  * The format is exactly:
 228  *     char subject[SMK_LABELLEN]
 229  *     char object[SMK_LABELLEN]
 230  *     char access[SMK_ACCESSKINDS]
 231  *
 232  *     Anything following is commentary and ignored.
 233  *
 234  * writes must be SMK_LABELLEN+SMK_LABELLEN+4 bytes.
 235  */
 236 #define MINIMUM_LOAD (SMK_LABELLEN + SMK_LABELLEN + SMK_ACCESSKINDS)
 237
 238 static ssize_t smk_write_load(struct file *file, const char __user *buf,
 239                               size_t count, loff_t *ppos)
 240 {
 241         struct smack_rule rule;
 242         char *data;
 243         int rc = -EINVAL;
 244
 245         /*
 246          * Must have privilege.
 247          * No partial writes.
 248          * Enough data must be present.
 249          */
 250         if (!capable(CAP_MAC_ADMIN))
 251                 return -EPERM;
 252         if (*ppos != 0)
 253                 return -EINVAL;
 254         if (count < MINIMUM_LOAD)
 255                 return -EINVAL;
 256
 257         data = kzalloc(count, GFP_KERNEL);
 258         if (data == NULL)
 259                 return -ENOMEM;
 260
 261         if (copy_from_user(data, buf, count) != 0) {
 262                 rc = -EFAULT;
 263                 goto out;
 264         }
 265
 266         rule.smk_subject = smk_import(data, 0);
 267         if (rule.smk_subject == NULL)
 268                 goto out;
 269
 270         rule.smk_object = smk_import(data + SMK_LABELLEN, 0);
 271         if (rule.smk_object == NULL)
 272                 goto out;
 273
 274         rule.smk_access = 0;
 275
 276         switch (data[SMK_LABELLEN + SMK_LABELLEN]) {
 277         case '-':
 278                 break;
 279         case 'r':
 280         case 'R':
 281                 rule.smk_access |= MAY_READ;
 282                 break;
 283         default:
 284                 goto out;
 285         }
 286
 287         switch (data[SMK_LABELLEN + SMK_LABELLEN + 1]) {
 288         case '-':
 289                 break;
 290         case 'w':
 291         case 'W':
 292                 rule.smk_access |= MAY_WRITE;
 293                 break;
 294         default:
 295                 goto out;
 296         }
 297
 298         switch (data[SMK_LABELLEN + SMK_LABELLEN + 2]) {
 299         case '-':
 300                 break;
 301         case 'x':
 302         case 'X':
 303                 rule.smk_access |= MAY_EXEC;
 304                 break;
 305         default:
 306                 goto out;
 307         }
 308
 309         switch (data[SMK_LABELLEN + SMK_LABELLEN + 3]) {
 310         case '-':
 311                 break;
 312         case 'a':
 313         case 'A':
 314                 rule.smk_access |= MAY_READ;
 315                 break;
 316         default:
 317                 goto out;
 318         }
 319
 320         smk_set_access(&rule);
 321         rc = count;
 322
 323 out:
 324         kfree(data);
 325         return rc;
 326 }
 327
 328 static const struct file_operations smk_load_ops = {
 329         .open           = smk_open_load,
 330         .read           = seq_read,
 331         .llseek         = seq_lseek,
 332         .write          = smk_write_load,
 333         .release        = smk_release_load,
 334 };
 335
 336 /**
 337  * smk_cipso_doi - initialize the CIPSO domain
 338  */
 339 void smk_cipso_doi(void)
 340 {
 341         int rc;
 342         struct cipso_v4_doi *doip;
 343         struct netlbl_audit audit_info;
 344
 345         rc = netlbl_cfg_map_del(NULL, &audit_info);
 346         if (rc != 0)
 347                 printk(KERN_WARNING "%s:%d remove rc = %d\n",
 348                        __func__, __LINE__, rc);
 349
 350         doip = kmalloc(sizeof(struct cipso_v4_doi), GFP_KERNEL);
 351         if (doip == NULL)
 352                 panic("smack:  Failed to initialize cipso DOI.\n");
 353         doip->map.std = NULL;
 354         doip->doi = smk_cipso_doi_value;
 355         doip->type = CIPSO_V4_MAP_PASS;
 356         doip->tags[0] = CIPSO_V4_TAG_RBITMAP;
 357         for (rc = 1; rc < CIPSO_V4_TAG_MAXCNT; rc++)
 358                 doip->tags[rc] = CIPSO_V4_TAG_INVALID;
 359
 360         rc = netlbl_cfg_cipsov4_add_map(doip, NULL, &audit_info);
 361         if (rc != 0)
 362                 printk(KERN_WARNING "%s:%d add rc = %d\n",
 363                        __func__, __LINE__, rc);
 364 }
 365
 366 /*
 367  * Seq_file read operations for /smack/cipso
 368  */
 369
 370 static void *cipso_seq_start(struct seq_file *s, loff_t *pos)
 371 {
 372         if (*pos == SEQ_READ_FINISHED)
 373                 return NULL;
 374
 375         return smack_known;
 376 }
 377
 378 static void *cipso_seq_next(struct seq_file *s, void *v, loff_t *pos)
 379 {
 380         struct smack_known *skp = ((struct smack_known *) v)->smk_next;
 381
 382         /*
 383          * Omit labels with no associated cipso value
 384          */
 385         while (skp != NULL && !skp->smk_cipso)
 386                 skp = skp->smk_next;
 387
 388         if (skp == NULL)
 389                 *pos = SEQ_READ_FINISHED;
 390
 391         return skp;
 392 }
 393
 394 /*
 395  * Print cipso labels in format:
 396  * label level[/cat[,cat]]
 397  */
 398 static int cipso_seq_show(struct seq_file *s, void *v)
 399 {
 400         struct smack_known *skp = (struct smack_known *) v;
 401         struct smack_cipso *scp = skp->smk_cipso;
 402         char *cbp;
 403         char sep = '/';
 404         int cat = 1;
 405         int i;
 406         unsigned char m;
 407
 408         if (scp == NULL)
 409                 return 0;
 410
 411         seq_printf(s, "%s %3d", (char *)&skp->smk_known, scp->smk_level);
 412
 413         cbp = scp->smk_catset;
 414         for (i = 0; i < SMK_LABELLEN; i++)
 415                 for (m = 0x80; m != 0; m >>= 1) {
 416                         if (m & cbp[i]) {
 417                                 seq_printf(s, "%c%d", sep, cat);
 418                                 sep = ',';
 419                         }
 420                         cat++;
 421                 }
 422
 423         seq_putc(s, '\n');
 424
 425         return 0;
 426 }
 427
 428 static void cipso_seq_stop(struct seq_file *s, void *v)
 429 {
 430         /* No-op */
 431 }
 432
 433 static struct seq_operations cipso_seq_ops = {
 434         .start = cipso_seq_start,
 435         .stop  = cipso_seq_stop,
 436         .next  = cipso_seq_next,
 437         .show  = cipso_seq_show,
 438 };
 439
 440 /**
 441  * smk_open_cipso - open() for /smack/cipso
 442  * @inode: inode structure representing file
 443  * @file: "cipso" file pointer
 444  *
 445  * Connect our cipso_seq_* operations with /smack/cipso
 446  * file_operations
 447  */
 448 static int smk_open_cipso(struct inode *inode, struct file *file)
 449 {
 450         return seq_open(file, &cipso_seq_ops);
 451 }
 452
 453 /**
 454  * smk_write_cipso - write() for /smack/cipso
 455  * @filp: file pointer, not actually used
 456  * @buf: where to get the data from
 457  * @count: bytes sent
 458  * @ppos: where to start
 459  *
 460  * Accepts only one cipso rule per write call.
 461  * Returns number of bytes written or error code, as appropriate
 462  */
 463 static ssize_t smk_write_cipso(struct file *file, const char __user *buf,
 464                                size_t count, loff_t *ppos)
 465 {
 466         struct smack_known *skp;
 467         struct smack_cipso *scp = NULL;
 468         char mapcatset[SMK_LABELLEN];
 469         int maplevel;
 470         int cat;
 471         int catlen;
 472         ssize_t rc = -EINVAL;
 473         char *data = NULL;
 474         char *rule;
 475         int ret;
 476         int i;
 477
 478         /*
 479          * Must have privilege.
 480          * No partial writes.
 481          * Enough data must be present.
 482          */
 483         if (!capable(CAP_MAC_ADMIN))
 484                 return -EPERM;
 485         if (*ppos != 0)
 486                 return -EINVAL;
 487         if (count <= SMK_CIPSOMIN)
 488                 return -EINVAL;
 489
 490         data = kzalloc(count + 1, GFP_KERNEL);
 491         if (data == NULL)
 492                 return -ENOMEM;
 493
 494         if (copy_from_user(data, buf, count) != 0) {
 495                 rc = -EFAULT;
 496                 goto unlockedout;
 497         }
 498
 499         data[count] = '\0';
 500         rule = data;
 501         /*
 502          * Only allow one writer at a time. Writes should be
 503          * quite rare and small in any case.
 504          */
 505         mutex_lock(&smack_cipso_lock);
 506
 507         skp = smk_import_entry(rule, 0);
 508         if (skp == NULL)
 509                 goto out;
 510
 511         rule += SMK_LABELLEN;;
 512         ret = sscanf(rule, "%d", &maplevel);
 513         if (ret != 1 || maplevel > SMACK_CIPSO_MAXLEVEL)
 514                 goto out;
 515
 516         rule += SMK_DIGITLEN;
 517         ret = sscanf(rule, "%d", &catlen);
 518         if (ret != 1 || catlen > SMACK_CIPSO_MAXCATNUM)
 519                 goto out;
 520
 521         if (count <= (SMK_CIPSOMIN + catlen * SMK_DIGITLEN))
 522                 goto out;
 523
 524         memset(mapcatset, 0, sizeof(mapcatset));
 525
 526         for (i = 0; i < catlen; i++) {
 527                 rule += SMK_DIGITLEN;
 528                 ret = sscanf(rule, "%d", &cat);
 529                 if (ret != 1 || cat > SMACK_CIPSO_MAXCATVAL)
 530                         goto out;
 531
 532                 smack_catset_bit(cat, mapcatset);
 533         }
 534
 535         if (skp->smk_cipso == NULL) {
 536                 scp = kzalloc(sizeof(struct smack_cipso), GFP_KERNEL);
 537                 if (scp == NULL) {
 538                         rc = -ENOMEM;
 539                         goto out;
 540                 }
 541         }
 542
 543         spin_lock_bh(&skp->smk_cipsolock);
 544
 545         if (scp == NULL)
 546                 scp = skp->smk_cipso;
 547         else
 548                 skp->smk_cipso = scp;
 549
 550         scp->smk_level = maplevel;
 551         memcpy(scp->smk_catset, mapcatset, sizeof(mapcatset));
 552
 553         spin_unlock_bh(&skp->smk_cipsolock);
 554
 555         rc = count;
 556 out:
 557         mutex_unlock(&smack_cipso_lock);
 558 unlockedout:
 559         kfree(data);
 560         return rc;
 561 }
 562
 563 static const struct file_operations smk_cipso_ops = {
 564         .open           = smk_open_cipso,
 565         .read           = seq_read,
 566         .llseek         = seq_lseek,
 567         .write          = smk_write_cipso,
 568         .release        = seq_release,
 569 };
 570
 571 /**
 572  * smk_read_doi - read() for /smack/doi
 573  * @filp: file pointer, not actually used
 574  * @buf: where to put the result
 575  * @count: maximum to send along
 576  * @ppos: where to start
 577  *
 578  * Returns number of bytes read or error code, as appropriate
 579  */
 580 static ssize_t smk_read_doi(struct file *filp, char __user *buf,
 581                             size_t count, loff_t *ppos)
 582 {
 583         char temp[80];
 584         ssize_t rc;
 585
 586         if (*ppos != 0)
 587                 return 0;
 588
 589         sprintf(temp, "%d", smk_cipso_doi_value);
 590         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
 591
 592         return rc;
 593 }
 594
 595 /**
 596  * smk_write_doi - write() for /smack/doi
 597  * @filp: file pointer, not actually used
 598  * @buf: where to get the data from
 599  * @count: bytes sent
 600  * @ppos: where to start
 601  *
 602  * Returns number of bytes written or error code, as appropriate
 603  */
 604 static ssize_t smk_write_doi(struct file *file, const char __user *buf,
 605                              size_t count, loff_t *ppos)
 606 {
 607         char temp[80];
 608         int i;
 609
 610         if (!capable(CAP_MAC_ADMIN))
 611                 return -EPERM;
 612
 613         if (count >= sizeof(temp) || count == 0)
 614                 return -EINVAL;
 615
 616         if (copy_from_user(temp, buf, count) != 0)
 617                 return -EFAULT;
 618
 619         temp[count] = '\0';
 620
 621         if (sscanf(temp, "%d", &i) != 1)
 622                 return -EINVAL;
 623
 624         smk_cipso_doi_value = i;
 625
 626         smk_cipso_doi();
 627
 628         return count;
 629 }
 630
 631 static const struct file_operations smk_doi_ops = {
 632         .read           = smk_read_doi,
 633         .write          = smk_write_doi,
 634 };
 635
 636 /**
 637  * smk_read_direct - read() for /smack/direct
 638  * @filp: file pointer, not actually used
 639  * @buf: where to put the result
 640  * @count: maximum to send along
 641  * @ppos: where to start
 642  *
 643  * Returns number of bytes read or error code, as appropriate
 644  */
 645 static ssize_t smk_read_direct(struct file *filp, char __user *buf,
 646                                size_t count, loff_t *ppos)
 647 {
 648         char temp[80];
 649         ssize_t rc;
 650
 651         if (*ppos != 0)
 652                 return 0;
 653
 654         sprintf(temp, "%d", smack_cipso_direct);
 655         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
 656
 657         return rc;
 658 }
 659
 660 /**
 661  * smk_write_direct - write() for /smack/direct
 662  * @filp: file pointer, not actually used
 663  * @buf: where to get the data from
 664  * @count: bytes sent
 665  * @ppos: where to start
 666  *
 667  * Returns number of bytes written or error code, as appropriate
 668  */
 669 static ssize_t smk_write_direct(struct file *file, const char __user *buf,
 670                                 size_t count, loff_t *ppos)
 671 {
 672         char temp[80];
 673         int i;
 674
 675         if (!capable(CAP_MAC_ADMIN))
 676                 return -EPERM;
 677
 678         if (count >= sizeof(temp) || count == 0)
 679                 return -EINVAL;
 680
 681         if (copy_from_user(temp, buf, count) != 0)
 682                 return -EFAULT;
 683
 684         temp[count] = '\0';
 685
 686         if (sscanf(temp, "%d", &i) != 1)
 687                 return -EINVAL;
 688
 689         smack_cipso_direct = i;
 690
 691         return count;
 692 }
 693
 694 static const struct file_operations smk_direct_ops = {
 695         .read           = smk_read_direct,
 696         .write          = smk_write_direct,
 697 };
 698
 699 /**
 700  * smk_read_ambient - read() for /smack/ambient
 701  * @filp: file pointer, not actually used
 702  * @buf: where to put the result
 703  * @cn: maximum to send along
 704  * @ppos: where to start
 705  *
 706  * Returns number of bytes read or error code, as appropriate
 707  */
 708 static ssize_t smk_read_ambient(struct file *filp, char __user *buf,
 709                                 size_t cn, loff_t *ppos)
 710 {
 711         ssize_t rc;
 712         char out[SMK_LABELLEN];
 713         int asize;
 714
 715         if (*ppos != 0)
 716                 return 0;
 717         /*
 718          * Being careful to avoid a problem in the case where
 719          * smack_net_ambient gets changed in midstream.
 720          * Since smack_net_ambient is always set with a value
 721          * from the label list, including initially, and those
 722          * never get freed, the worst case is that the pointer
 723          * gets changed just after this strncpy, in which case
 724          * the value passed up is incorrect. Locking around
 725          * smack_net_ambient wouldn't be any better than this
 726          * copy scheme as by the time the caller got to look
 727          * at the ambient value it would have cleared the lock
 728          * and been changed.
 729          */
 730         strncpy(out, smack_net_ambient, SMK_LABELLEN);
 731         asize = strlen(out) + 1;
 732
 733         if (cn < asize)
 734                 return -EINVAL;
 735
 736         rc = simple_read_from_buffer(buf, cn, ppos, out, asize);
 737
 738         return rc;
 739 }
 740
 741 /**
 742  * smk_write_ambient - write() for /smack/ambient
 743  * @filp: file pointer, not actually used
 744  * @buf: where to get the data from
 745  * @count: bytes sent
 746  * @ppos: where to start
 747  *
 748  * Returns number of bytes written or error code, as appropriate
 749  */
 750 static ssize_t smk_write_ambient(struct file *file, const char __user *buf,
 751                                  size_t count, loff_t *ppos)
 752 {
 753         char in[SMK_LABELLEN];
 754         char *smack;
 755
 756         if (!capable(CAP_MAC_ADMIN))
 757                 return -EPERM;
 758
 759         if (count >= SMK_LABELLEN)
 760                 return -EINVAL;
 761
 762         if (copy_from_user(in, buf, count) != 0)
 763                 return -EFAULT;
 764
 765         smack = smk_import(in, count);
 766         if (smack == NULL)
 767                 return -EINVAL;
 768
 769         smack_net_ambient = smack;
 770
 771         return count;
 772 }
 773
 774 static const struct file_operations smk_ambient_ops = {
 775         .read           = smk_read_ambient,
 776         .write          = smk_write_ambient,
 777 };
 778
 779 struct option_names {
 780         int     o_number;
 781         char    *o_name;
 782         char    *o_alias;
 783 };
 784
 785 static struct option_names netlbl_choices[] = {
 786         { NETLBL_NLTYPE_RIPSO,
 787                 NETLBL_NLTYPE_RIPSO_NAME,       "ripso" },
 788         { NETLBL_NLTYPE_CIPSOV4,
 789                 NETLBL_NLTYPE_CIPSOV4_NAME,     "cipsov4" },
 790         { NETLBL_NLTYPE_CIPSOV4,
 791                 NETLBL_NLTYPE_CIPSOV4_NAME,     "cipso" },
 792         { NETLBL_NLTYPE_CIPSOV6,
 793                 NETLBL_NLTYPE_CIPSOV6_NAME,     "cipsov6" },
 794         { NETLBL_NLTYPE_UNLABELED,
 795                 NETLBL_NLTYPE_UNLABELED_NAME,   "unlabeled" },
 796 };
 797
 798 /**
 799  * smk_read_nltype - read() for /smack/nltype
 800  * @filp: file pointer, not actually used
 801  * @buf: where to put the result
 802  * @count: maximum to send along
 803  * @ppos: where to start
 804  *
 805  * Returns number of bytes read or error code, as appropriate
 806  */
 807 static ssize_t smk_read_nltype(struct file *filp, char __user *buf,
 808                                size_t count, loff_t *ppos)
 809 {
 810         char bound[40];
 811         ssize_t rc;
 812         int i;
 813
 814         if (count < SMK_LABELLEN)
 815                 return -EINVAL;
 816
 817         if (*ppos != 0)
 818                 return 0;
 819
 820         sprintf(bound, "unknown");
 821
 822         for (i = 0; i < ARRAY_SIZE(netlbl_choices); i++)
 823                 if (smack_net_nltype == netlbl_choices[i].o_number) {
 824                         sprintf(bound, "%s", netlbl_choices[i].o_name);
 825                         break;
 826                 }
 827
 828         rc = simple_read_from_buffer(buf, count, ppos, bound, strlen(bound));
 829
 830         return rc;
 831 }
 832
 833 /**
 834  * smk_write_nltype - write() for /smack/nltype
 835  * @filp: file pointer, not actually used
 836  * @buf: where to get the data from
 837  * @count: bytes sent
 838  * @ppos: where to start
 839  *
 840  * Returns number of bytes written or error code, as appropriate
 841  */
 842 static ssize_t smk_write_nltype(struct file *file, const char __user *buf,
 843                                 size_t count, loff_t *ppos)
 844 {
 845         char bound[40];
 846         char *cp;
 847         int i;
 848
 849         if (!capable(CAP_MAC_ADMIN))
 850                 return -EPERM;
 851
 852         if (count >= 40)
 853                 return -EINVAL;
 854
 855         if (copy_from_user(bound, buf, count) != 0)
 856                 return -EFAULT;
 857
 858         bound[count] = '\0';
 859         cp = strchr(bound, ' ');
 860         if (cp != NULL)
 861                 *cp = '\0';
 862         cp = strchr(bound, '\n');
 863         if (cp != NULL)
 864                 *cp = '\0';
 865
 866         for (i = 0; i < ARRAY_SIZE(netlbl_choices); i++)
 867                 if (strcmp(bound, netlbl_choices[i].o_name) == 0 ||
 868                     strcmp(bound, netlbl_choices[i].o_alias) == 0) {
 869                         smack_net_nltype = netlbl_choices[i].o_number;
 870                         return count;
 871                 }
 872         /*
 873          * Not a valid choice.
 874          */
 875         return -EINVAL;
 876 }
 877
 878 static const struct file_operations smk_nltype_ops = {
 879         .read           = smk_read_nltype,
 880         .write          = smk_write_nltype,
 881 };
 882
 883 /**
 884  * smk_fill_super - fill the /smackfs superblock
 885  * @sb: the empty superblock
 886  * @data: unused
 887  * @silent: unused
 888  *
 889  * Fill in the well known entries for /smack
 890  *
 891  * Returns 0 on success, an error code on failure
 892  */
 893 static int smk_fill_super(struct super_block *sb, void *data, int silent)
 894 {
 895         int rc;
 896         struct inode *root_inode;
 897
 898         static struct tree_descr smack_files[] = {
 899                 [SMK_LOAD]      =
 900                         {"load", &smk_load_ops, S_IRUGO|S_IWUSR},
 901                 [SMK_CIPSO]     =
 902                         {"cipso", &smk_cipso_ops, S_IRUGO|S_IWUSR},
 903                 [SMK_DOI]       =
 904                         {"doi", &smk_doi_ops, S_IRUGO|S_IWUSR},
 905                 [SMK_DIRECT]    =
 906                         {"direct", &smk_direct_ops, S_IRUGO|S_IWUSR},
 907                 [SMK_AMBIENT]   =
 908                         {"ambient", &smk_ambient_ops, S_IRUGO|S_IWUSR},
 909                 [SMK_NLTYPE]    =
 910                         {"nltype", &smk_nltype_ops, S_IRUGO|S_IWUSR},
 911                 /* last one */ {""}
 912         };
 913
 914         rc = simple_fill_super(sb, SMACK_MAGIC, smack_files);
 915         if (rc != 0) {
 916                 printk(KERN_ERR "%s failed %d while creating inodes\n",
 917                         __func__, rc);
 918                 return rc;
 919         }
 920
 921         root_inode = sb->s_root->d_inode;
 922         root_inode->i_security = new_inode_smack(smack_known_floor.smk_known);
 923
 924         return 0;
 925 }
 926
 927 /**
 928  * smk_get_sb - get the smackfs superblock
 929  * @fs_type: passed along without comment
 930  * @flags: passed along without comment
 931  * @dev_name: passed along without comment
 932  * @data: passed along without comment
 933  * @mnt: passed along without comment
 934  *
 935  * Just passes everything along.
 936  *
 937  * Returns what the lower level code does.
 938  */
 939 static int smk_get_sb(struct file_system_type *fs_type,
 940                       int flags, const char *dev_name, void *data,
 941                       struct vfsmount *mnt)
 942 {
 943         return get_sb_single(fs_type, flags, data, smk_fill_super, mnt);
 944 }
 945
 946 static struct file_system_type smk_fs_type = {
 947         .name           = "smackfs",
 948         .get_sb         = smk_get_sb,
 949         .kill_sb        = kill_litter_super,
 950 };
 951
 952 static struct vfsmount *smackfs_mount;
 953
 954 /**
 955  * init_smk_fs - get the smackfs superblock
 956  *
 957  * register the smackfs
 958  *
 959  * Returns 0 unless the registration fails.
 960  */
 961 static int __init init_smk_fs(void)
 962 {
 963         int err;
 964
 965         err = register_filesystem(&smk_fs_type);
 966         if (!err) {
 967                 smackfs_mount = kern_mount(&smk_fs_type);
 968                 if (IS_ERR(smackfs_mount)) {
 969                         printk(KERN_ERR "smackfs:  could not mount!\n");
 970                         err = PTR_ERR(smackfs_mount);
 971                         smackfs_mount = NULL;
 972                 }
 973         }
 974
 975         sema_init(&smack_write_sem, 1);
 976         smk_cipso_doi();
 977
 978         return err;
 979 }
 980
 981 __initcall(init_smk_fs);