Merge branch 'next' of git://git.infradead.org/users/pcmoore/selinux into next
[sfrench/cifs-2.6.git] / 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 <linux/slab.h>
24 #include <net/net_namespace.h>
25 #include <net/cipso_ipv4.h>
26 #include <linux/seq_file.h>
27 #include <linux/ctype.h>
28 #include <linux/audit.h>
29 #include <linux/magic.h>
30 #include "smack.h"
31
32 /*
33  * smackfs pseudo filesystem.
34  */
35
36 enum smk_inos {
37         SMK_ROOT_INO    = 2,
38         SMK_LOAD        = 3,    /* load policy */
39         SMK_CIPSO       = 4,    /* load label -> CIPSO mapping */
40         SMK_DOI         = 5,    /* CIPSO DOI */
41         SMK_DIRECT      = 6,    /* CIPSO level indicating direct label */
42         SMK_AMBIENT     = 7,    /* internet ambient label */
43         SMK_NETLBLADDR  = 8,    /* single label hosts */
44         SMK_ONLYCAP     = 9,    /* the only "capable" label */
45         SMK_LOGGING     = 10,   /* logging */
46         SMK_LOAD_SELF   = 11,   /* task specific rules */
47         SMK_ACCESSES    = 12,   /* access policy */
48         SMK_MAPPED      = 13,   /* CIPSO level indicating mapped label */
49         SMK_LOAD2       = 14,   /* load policy with long labels */
50         SMK_LOAD_SELF2  = 15,   /* load task specific rules with long labels */
51         SMK_ACCESS2     = 16,   /* make an access check with long labels */
52         SMK_CIPSO2      = 17,   /* load long label -> CIPSO mapping */
53         SMK_REVOKE_SUBJ = 18,   /* set rules with subject label to '-' */
54         SMK_CHANGE_RULE = 19,   /* change or add rules (long labels) */
55         SMK_SYSLOG      = 20,   /* change syslog label) */
56         SMK_PTRACE      = 21,   /* set ptrace rule */
57 };
58
59 /*
60  * List locks
61  */
62 static DEFINE_MUTEX(smack_cipso_lock);
63 static DEFINE_MUTEX(smack_ambient_lock);
64 static DEFINE_MUTEX(smack_syslog_lock);
65 static DEFINE_MUTEX(smk_netlbladdr_lock);
66
67 /*
68  * This is the "ambient" label for network traffic.
69  * If it isn't somehow marked, use this.
70  * It can be reset via smackfs/ambient
71  */
72 struct smack_known *smack_net_ambient;
73
74 /*
75  * This is the level in a CIPSO header that indicates a
76  * smack label is contained directly in the category set.
77  * It can be reset via smackfs/direct
78  */
79 int smack_cipso_direct = SMACK_CIPSO_DIRECT_DEFAULT;
80
81 /*
82  * This is the level in a CIPSO header that indicates a
83  * secid is contained directly in the category set.
84  * It can be reset via smackfs/mapped
85  */
86 int smack_cipso_mapped = SMACK_CIPSO_MAPPED_DEFAULT;
87
88 /*
89  * Unless a process is running with this label even
90  * having CAP_MAC_OVERRIDE isn't enough to grant
91  * privilege to violate MAC policy. If no label is
92  * designated (the NULL case) capabilities apply to
93  * everyone. It is expected that the hat (^) label
94  * will be used if any label is used.
95  */
96 struct smack_known *smack_onlycap;
97
98 /*
99  * If this value is set restrict syslog use to the label specified.
100  * It can be reset via smackfs/syslog
101  */
102 struct smack_known *smack_syslog_label;
103
104 /*
105  * Ptrace current rule
106  * SMACK_PTRACE_DEFAULT    regular smack ptrace rules (/proc based)
107  * SMACK_PTRACE_EXACT      labels must match, but can be overriden with
108  *                         CAP_SYS_PTRACE
109  * SMACK_PTRACE_DRACONIAN  lables must match, CAP_SYS_PTRACE has no effect
110  */
111 int smack_ptrace_rule = SMACK_PTRACE_DEFAULT;
112
113 /*
114  * Certain IP addresses may be designated as single label hosts.
115  * Packets are sent there unlabeled, but only from tasks that
116  * can write to the specified label.
117  */
118
119 LIST_HEAD(smk_netlbladdr_list);
120
121 /*
122  * Rule lists are maintained for each label.
123  * This master list is just for reading /smack/load and /smack/load2.
124  */
125 struct smack_master_list {
126         struct list_head        list;
127         struct smack_rule       *smk_rule;
128 };
129
130 LIST_HEAD(smack_rule_list);
131
132 struct smack_parsed_rule {
133         struct smack_known      *smk_subject;
134         char                    *smk_object;
135         int                     smk_access1;
136         int                     smk_access2;
137 };
138
139 static int smk_cipso_doi_value = SMACK_CIPSO_DOI_DEFAULT;
140
141 const char *smack_cipso_option = SMACK_CIPSO_OPTION;
142
143 /*
144  * Values for parsing cipso rules
145  * SMK_DIGITLEN: Length of a digit field in a rule.
146  * SMK_CIPSOMIN: Minimum possible cipso rule length.
147  * SMK_CIPSOMAX: Maximum possible cipso rule length.
148  */
149 #define SMK_DIGITLEN 4
150 #define SMK_CIPSOMIN (SMK_LABELLEN + 2 * SMK_DIGITLEN)
151 #define SMK_CIPSOMAX (SMK_CIPSOMIN + SMACK_CIPSO_MAXCATNUM * SMK_DIGITLEN)
152
153 /*
154  * Values for parsing MAC rules
155  * SMK_ACCESS: Maximum possible combination of access permissions
156  * SMK_ACCESSLEN: Maximum length for a rule access field
157  * SMK_LOADLEN: Smack rule length
158  */
159 #define SMK_OACCESS     "rwxa"
160 #define SMK_ACCESS      "rwxatl"
161 #define SMK_OACCESSLEN  (sizeof(SMK_OACCESS) - 1)
162 #define SMK_ACCESSLEN   (sizeof(SMK_ACCESS) - 1)
163 #define SMK_OLOADLEN    (SMK_LABELLEN + SMK_LABELLEN + SMK_OACCESSLEN)
164 #define SMK_LOADLEN     (SMK_LABELLEN + SMK_LABELLEN + SMK_ACCESSLEN)
165
166 /*
167  * Stricly for CIPSO level manipulation.
168  * Set the category bit number in a smack label sized buffer.
169  */
170 static inline void smack_catset_bit(unsigned int cat, char *catsetp)
171 {
172         if (cat == 0 || cat > (SMK_CIPSOLEN * 8))
173                 return;
174
175         catsetp[(cat - 1) / 8] |= 0x80 >> ((cat - 1) % 8);
176 }
177
178 /**
179  * smk_netlabel_audit_set - fill a netlbl_audit struct
180  * @nap: structure to fill
181  */
182 static void smk_netlabel_audit_set(struct netlbl_audit *nap)
183 {
184         struct smack_known *skp = smk_of_current();
185
186         nap->loginuid = audit_get_loginuid(current);
187         nap->sessionid = audit_get_sessionid(current);
188         nap->secid = skp->smk_secid;
189 }
190
191 /*
192  * Value for parsing single label host rules
193  * "1.2.3.4 X"
194  */
195 #define SMK_NETLBLADDRMIN       9
196
197 /**
198  * smk_set_access - add a rule to the rule list or replace an old rule
199  * @srp: the rule to add or replace
200  * @rule_list: the list of rules
201  * @rule_lock: the rule list lock
202  * @global: if non-zero, indicates a global rule
203  *
204  * Looks through the current subject/object/access list for
205  * the subject/object pair and replaces the access that was
206  * there. If the pair isn't found add it with the specified
207  * access.
208  *
209  * Returns 0 if nothing goes wrong or -ENOMEM if it fails
210  * during the allocation of the new pair to add.
211  */
212 static int smk_set_access(struct smack_parsed_rule *srp,
213                                 struct list_head *rule_list,
214                                 struct mutex *rule_lock, int global)
215 {
216         struct smack_rule *sp;
217         struct smack_master_list *smlp;
218         int found = 0;
219         int rc = 0;
220
221         mutex_lock(rule_lock);
222
223         /*
224          * Because the object label is less likely to match
225          * than the subject label check it first
226          */
227         list_for_each_entry_rcu(sp, rule_list, list) {
228                 if (sp->smk_object == srp->smk_object &&
229                     sp->smk_subject == srp->smk_subject) {
230                         found = 1;
231                         sp->smk_access |= srp->smk_access1;
232                         sp->smk_access &= ~srp->smk_access2;
233                         break;
234                 }
235         }
236
237         if (found == 0) {
238                 sp = kzalloc(sizeof(*sp), GFP_KERNEL);
239                 if (sp == NULL) {
240                         rc = -ENOMEM;
241                         goto out;
242                 }
243
244                 sp->smk_subject = srp->smk_subject;
245                 sp->smk_object = srp->smk_object;
246                 sp->smk_access = srp->smk_access1 & ~srp->smk_access2;
247
248                 list_add_rcu(&sp->list, rule_list);
249                 /*
250                  * If this is a global as opposed to self and a new rule
251                  * it needs to get added for reporting.
252                  */
253                 if (global) {
254                         smlp = kzalloc(sizeof(*smlp), GFP_KERNEL);
255                         if (smlp != NULL) {
256                                 smlp->smk_rule = sp;
257                                 list_add_rcu(&smlp->list, &smack_rule_list);
258                         } else
259                                 rc = -ENOMEM;
260                 }
261         }
262
263 out:
264         mutex_unlock(rule_lock);
265         return rc;
266 }
267
268 /**
269  * smk_perm_from_str - parse smack accesses from a text string
270  * @string: a text string that contains a Smack accesses code
271  *
272  * Returns an integer with respective bits set for specified accesses.
273  */
274 static int smk_perm_from_str(const char *string)
275 {
276         int perm = 0;
277         const char *cp;
278
279         for (cp = string; ; cp++)
280                 switch (*cp) {
281                 case '-':
282                         break;
283                 case 'r':
284                 case 'R':
285                         perm |= MAY_READ;
286                         break;
287                 case 'w':
288                 case 'W':
289                         perm |= MAY_WRITE;
290                         break;
291                 case 'x':
292                 case 'X':
293                         perm |= MAY_EXEC;
294                         break;
295                 case 'a':
296                 case 'A':
297                         perm |= MAY_APPEND;
298                         break;
299                 case 't':
300                 case 'T':
301                         perm |= MAY_TRANSMUTE;
302                         break;
303                 case 'l':
304                 case 'L':
305                         perm |= MAY_LOCK;
306                         break;
307                 default:
308                         return perm;
309                 }
310 }
311
312 /**
313  * smk_fill_rule - Fill Smack rule from strings
314  * @subject: subject label string
315  * @object: object label string
316  * @access1: access string
317  * @access2: string with permissions to be removed
318  * @rule: Smack rule
319  * @import: if non-zero, import labels
320  * @len: label length limit
321  *
322  * Returns 0 on success, -EINVAL on failure and -ENOENT when either subject
323  * or object is missing.
324  */
325 static int smk_fill_rule(const char *subject, const char *object,
326                                 const char *access1, const char *access2,
327                                 struct smack_parsed_rule *rule, int import,
328                                 int len)
329 {
330         const char *cp;
331         struct smack_known *skp;
332
333         if (import) {
334                 rule->smk_subject = smk_import_entry(subject, len);
335                 if (rule->smk_subject == NULL)
336                         return -EINVAL;
337
338                 rule->smk_object = smk_import(object, len);
339                 if (rule->smk_object == NULL)
340                         return -EINVAL;
341         } else {
342                 cp = smk_parse_smack(subject, len);
343                 if (cp == NULL)
344                         return -EINVAL;
345                 skp = smk_find_entry(cp);
346                 kfree(cp);
347                 if (skp == NULL)
348                         return -ENOENT;
349                 rule->smk_subject = skp;
350
351                 cp = smk_parse_smack(object, len);
352                 if (cp == NULL)
353                         return -EINVAL;
354                 skp = smk_find_entry(cp);
355                 kfree(cp);
356                 if (skp == NULL)
357                         return -ENOENT;
358                 rule->smk_object = skp->smk_known;
359         }
360
361         rule->smk_access1 = smk_perm_from_str(access1);
362         if (access2)
363                 rule->smk_access2 = smk_perm_from_str(access2);
364         else
365                 rule->smk_access2 = ~rule->smk_access1;
366
367         return 0;
368 }
369
370 /**
371  * smk_parse_rule - parse Smack rule from load string
372  * @data: string to be parsed whose size is SMK_LOADLEN
373  * @rule: Smack rule
374  * @import: if non-zero, import labels
375  *
376  * Returns 0 on success, -1 on errors.
377  */
378 static int smk_parse_rule(const char *data, struct smack_parsed_rule *rule,
379                                 int import)
380 {
381         int rc;
382
383         rc = smk_fill_rule(data, data + SMK_LABELLEN,
384                            data + SMK_LABELLEN + SMK_LABELLEN, NULL, rule,
385                            import, SMK_LABELLEN);
386         return rc;
387 }
388
389 /**
390  * smk_parse_long_rule - parse Smack rule from rule string
391  * @data: string to be parsed, null terminated
392  * @rule: Will be filled with Smack parsed rule
393  * @import: if non-zero, import labels
394  * @tokens: numer of substrings expected in data
395  *
396  * Returns number of processed bytes on success, -1 on failure.
397  */
398 static ssize_t smk_parse_long_rule(char *data, struct smack_parsed_rule *rule,
399                                 int import, int tokens)
400 {
401         ssize_t cnt = 0;
402         char *tok[4];
403         int rc;
404         int i;
405
406         /*
407          * Parsing the rule in-place, filling all white-spaces with '\0'
408          */
409         for (i = 0; i < tokens; ++i) {
410                 while (isspace(data[cnt]))
411                         data[cnt++] = '\0';
412
413                 if (data[cnt] == '\0')
414                         /* Unexpected end of data */
415                         return -1;
416
417                 tok[i] = data + cnt;
418
419                 while (data[cnt] && !isspace(data[cnt]))
420                         ++cnt;
421         }
422         while (isspace(data[cnt]))
423                 data[cnt++] = '\0';
424
425         while (i < 4)
426                 tok[i++] = NULL;
427
428         rc = smk_fill_rule(tok[0], tok[1], tok[2], tok[3], rule, import, 0);
429         return rc == 0 ? cnt : rc;
430 }
431
432 #define SMK_FIXED24_FMT 0       /* Fixed 24byte label format */
433 #define SMK_LONG_FMT    1       /* Variable long label format */
434 #define SMK_CHANGE_FMT  2       /* Rule modification format */
435 /**
436  * smk_write_rules_list - write() for any /smack rule file
437  * @file: file pointer, not actually used
438  * @buf: where to get the data from
439  * @count: bytes sent
440  * @ppos: where to start - must be 0
441  * @rule_list: the list of rules to write to
442  * @rule_lock: lock for the rule list
443  * @format: /smack/load or /smack/load2 or /smack/change-rule format.
444  *
445  * Get one smack access rule from above.
446  * The format for SMK_LONG_FMT is:
447  *      "subject<whitespace>object<whitespace>access[<whitespace>...]"
448  * The format for SMK_FIXED24_FMT is exactly:
449  *      "subject                 object                  rwxat"
450  * The format for SMK_CHANGE_FMT is:
451  *      "subject<whitespace>object<whitespace>
452  *       acc_enable<whitespace>acc_disable[<whitespace>...]"
453  */
454 static ssize_t smk_write_rules_list(struct file *file, const char __user *buf,
455                                         size_t count, loff_t *ppos,
456                                         struct list_head *rule_list,
457                                         struct mutex *rule_lock, int format)
458 {
459         struct smack_parsed_rule rule;
460         char *data;
461         int rc;
462         int trunc = 0;
463         int tokens;
464         ssize_t cnt = 0;
465
466         /*
467          * No partial writes.
468          * Enough data must be present.
469          */
470         if (*ppos != 0)
471                 return -EINVAL;
472
473         if (format == SMK_FIXED24_FMT) {
474                 /*
475                  * Minor hack for backward compatibility
476                  */
477                 if (count < SMK_OLOADLEN || count > SMK_LOADLEN)
478                         return -EINVAL;
479         } else {
480                 if (count >= PAGE_SIZE) {
481                         count = PAGE_SIZE - 1;
482                         trunc = 1;
483                 }
484         }
485
486         data = kmalloc(count + 1, GFP_KERNEL);
487         if (data == NULL)
488                 return -ENOMEM;
489
490         if (copy_from_user(data, buf, count) != 0) {
491                 rc = -EFAULT;
492                 goto out;
493         }
494
495         /*
496          * In case of parsing only part of user buf,
497          * avoid having partial rule at the data buffer
498          */
499         if (trunc) {
500                 while (count > 0 && (data[count - 1] != '\n'))
501                         --count;
502                 if (count == 0) {
503                         rc = -EINVAL;
504                         goto out;
505                 }
506         }
507
508         data[count] = '\0';
509         tokens = (format == SMK_CHANGE_FMT ? 4 : 3);
510         while (cnt < count) {
511                 if (format == SMK_FIXED24_FMT) {
512                         rc = smk_parse_rule(data, &rule, 1);
513                         if (rc != 0) {
514                                 rc = -EINVAL;
515                                 goto out;
516                         }
517                         cnt = count;
518                 } else {
519                         rc = smk_parse_long_rule(data + cnt, &rule, 1, tokens);
520                         if (rc <= 0) {
521                                 rc = -EINVAL;
522                                 goto out;
523                         }
524                         cnt += rc;
525                 }
526
527                 if (rule_list == NULL)
528                         rc = smk_set_access(&rule, &rule.smk_subject->smk_rules,
529                                 &rule.smk_subject->smk_rules_lock, 1);
530                 else
531                         rc = smk_set_access(&rule, rule_list, rule_lock, 0);
532
533                 if (rc)
534                         goto out;
535         }
536
537         rc = cnt;
538 out:
539         kfree(data);
540         return rc;
541 }
542
543 /*
544  * Core logic for smackfs seq list operations.
545  */
546
547 static void *smk_seq_start(struct seq_file *s, loff_t *pos,
548                                 struct list_head *head)
549 {
550         struct list_head *list;
551
552         /*
553          * This is 0 the first time through.
554          */
555         if (s->index == 0)
556                 s->private = head;
557
558         if (s->private == NULL)
559                 return NULL;
560
561         list = s->private;
562         if (list_empty(list))
563                 return NULL;
564
565         if (s->index == 0)
566                 return list->next;
567         return list;
568 }
569
570 static void *smk_seq_next(struct seq_file *s, void *v, loff_t *pos,
571                                 struct list_head *head)
572 {
573         struct list_head *list = v;
574
575         if (list_is_last(list, head)) {
576                 s->private = NULL;
577                 return NULL;
578         }
579         s->private = list->next;
580         return list->next;
581 }
582
583 static void smk_seq_stop(struct seq_file *s, void *v)
584 {
585         /* No-op */
586 }
587
588 static void smk_rule_show(struct seq_file *s, struct smack_rule *srp, int max)
589 {
590         /*
591          * Don't show any rules with label names too long for
592          * interface file (/smack/load or /smack/load2)
593          * because you should expect to be able to write
594          * anything you read back.
595          */
596         if (strlen(srp->smk_subject->smk_known) >= max ||
597             strlen(srp->smk_object) >= max)
598                 return;
599
600         if (srp->smk_access == 0)
601                 return;
602
603         seq_printf(s, "%s %s", srp->smk_subject->smk_known, srp->smk_object);
604
605         seq_putc(s, ' ');
606
607         if (srp->smk_access & MAY_READ)
608                 seq_putc(s, 'r');
609         if (srp->smk_access & MAY_WRITE)
610                 seq_putc(s, 'w');
611         if (srp->smk_access & MAY_EXEC)
612                 seq_putc(s, 'x');
613         if (srp->smk_access & MAY_APPEND)
614                 seq_putc(s, 'a');
615         if (srp->smk_access & MAY_TRANSMUTE)
616                 seq_putc(s, 't');
617         if (srp->smk_access & MAY_LOCK)
618                 seq_putc(s, 'l');
619
620         seq_putc(s, '\n');
621 }
622
623 /*
624  * Seq_file read operations for /smack/load
625  */
626
627 static void *load2_seq_start(struct seq_file *s, loff_t *pos)
628 {
629         return smk_seq_start(s, pos, &smack_rule_list);
630 }
631
632 static void *load2_seq_next(struct seq_file *s, void *v, loff_t *pos)
633 {
634         return smk_seq_next(s, v, pos, &smack_rule_list);
635 }
636
637 static int load_seq_show(struct seq_file *s, void *v)
638 {
639         struct list_head *list = v;
640         struct smack_master_list *smlp =
641                  list_entry(list, struct smack_master_list, list);
642
643         smk_rule_show(s, smlp->smk_rule, SMK_LABELLEN);
644
645         return 0;
646 }
647
648 static const struct seq_operations load_seq_ops = {
649         .start = load2_seq_start,
650         .next  = load2_seq_next,
651         .show  = load_seq_show,
652         .stop  = smk_seq_stop,
653 };
654
655 /**
656  * smk_open_load - open() for /smack/load
657  * @inode: inode structure representing file
658  * @file: "load" file pointer
659  *
660  * For reading, use load_seq_* seq_file reading operations.
661  */
662 static int smk_open_load(struct inode *inode, struct file *file)
663 {
664         return seq_open(file, &load_seq_ops);
665 }
666
667 /**
668  * smk_write_load - write() for /smack/load
669  * @file: file pointer, not actually used
670  * @buf: where to get the data from
671  * @count: bytes sent
672  * @ppos: where to start - must be 0
673  *
674  */
675 static ssize_t smk_write_load(struct file *file, const char __user *buf,
676                               size_t count, loff_t *ppos)
677 {
678         /*
679          * Must have privilege.
680          * No partial writes.
681          * Enough data must be present.
682          */
683         if (!smack_privileged(CAP_MAC_ADMIN))
684                 return -EPERM;
685
686         return smk_write_rules_list(file, buf, count, ppos, NULL, NULL,
687                                     SMK_FIXED24_FMT);
688 }
689
690 static const struct file_operations smk_load_ops = {
691         .open           = smk_open_load,
692         .read           = seq_read,
693         .llseek         = seq_lseek,
694         .write          = smk_write_load,
695         .release        = seq_release,
696 };
697
698 /**
699  * smk_cipso_doi - initialize the CIPSO domain
700  */
701 static void smk_cipso_doi(void)
702 {
703         int rc;
704         struct cipso_v4_doi *doip;
705         struct netlbl_audit nai;
706
707         smk_netlabel_audit_set(&nai);
708
709         rc = netlbl_cfg_map_del(NULL, PF_INET, NULL, NULL, &nai);
710         if (rc != 0)
711                 printk(KERN_WARNING "%s:%d remove rc = %d\n",
712                        __func__, __LINE__, rc);
713
714         doip = kmalloc(sizeof(struct cipso_v4_doi), GFP_KERNEL);
715         if (doip == NULL)
716                 panic("smack:  Failed to initialize cipso DOI.\n");
717         doip->map.std = NULL;
718         doip->doi = smk_cipso_doi_value;
719         doip->type = CIPSO_V4_MAP_PASS;
720         doip->tags[0] = CIPSO_V4_TAG_RBITMAP;
721         for (rc = 1; rc < CIPSO_V4_TAG_MAXCNT; rc++)
722                 doip->tags[rc] = CIPSO_V4_TAG_INVALID;
723
724         rc = netlbl_cfg_cipsov4_add(doip, &nai);
725         if (rc != 0) {
726                 printk(KERN_WARNING "%s:%d cipso add rc = %d\n",
727                        __func__, __LINE__, rc);
728                 kfree(doip);
729                 return;
730         }
731         rc = netlbl_cfg_cipsov4_map_add(doip->doi, NULL, NULL, NULL, &nai);
732         if (rc != 0) {
733                 printk(KERN_WARNING "%s:%d map add rc = %d\n",
734                        __func__, __LINE__, rc);
735                 kfree(doip);
736                 return;
737         }
738 }
739
740 /**
741  * smk_unlbl_ambient - initialize the unlabeled domain
742  * @oldambient: previous domain string
743  */
744 static void smk_unlbl_ambient(char *oldambient)
745 {
746         int rc;
747         struct netlbl_audit nai;
748
749         smk_netlabel_audit_set(&nai);
750
751         if (oldambient != NULL) {
752                 rc = netlbl_cfg_map_del(oldambient, PF_INET, NULL, NULL, &nai);
753                 if (rc != 0)
754                         printk(KERN_WARNING "%s:%d remove rc = %d\n",
755                                __func__, __LINE__, rc);
756         }
757         if (smack_net_ambient == NULL)
758                 smack_net_ambient = &smack_known_floor;
759
760         rc = netlbl_cfg_unlbl_map_add(smack_net_ambient->smk_known, PF_INET,
761                                       NULL, NULL, &nai);
762         if (rc != 0)
763                 printk(KERN_WARNING "%s:%d add rc = %d\n",
764                        __func__, __LINE__, rc);
765 }
766
767 /*
768  * Seq_file read operations for /smack/cipso
769  */
770
771 static void *cipso_seq_start(struct seq_file *s, loff_t *pos)
772 {
773         return smk_seq_start(s, pos, &smack_known_list);
774 }
775
776 static void *cipso_seq_next(struct seq_file *s, void *v, loff_t *pos)
777 {
778         return smk_seq_next(s, v, pos, &smack_known_list);
779 }
780
781 /*
782  * Print cipso labels in format:
783  * label level[/cat[,cat]]
784  */
785 static int cipso_seq_show(struct seq_file *s, void *v)
786 {
787         struct list_head  *list = v;
788         struct smack_known *skp =
789                  list_entry(list, struct smack_known, list);
790         struct netlbl_lsm_catmap *cmp = skp->smk_netlabel.attr.mls.cat;
791         char sep = '/';
792         int i;
793
794         /*
795          * Don't show a label that could not have been set using
796          * /smack/cipso. This is in support of the notion that
797          * anything read from /smack/cipso ought to be writeable
798          * to /smack/cipso.
799          *
800          * /smack/cipso2 should be used instead.
801          */
802         if (strlen(skp->smk_known) >= SMK_LABELLEN)
803                 return 0;
804
805         seq_printf(s, "%s %3d", skp->smk_known, skp->smk_netlabel.attr.mls.lvl);
806
807         for (i = netlbl_catmap_walk(cmp, 0); i >= 0;
808              i = netlbl_catmap_walk(cmp, i + 1)) {
809                 seq_printf(s, "%c%d", sep, i);
810                 sep = ',';
811         }
812
813         seq_putc(s, '\n');
814
815         return 0;
816 }
817
818 static const struct seq_operations cipso_seq_ops = {
819         .start = cipso_seq_start,
820         .next  = cipso_seq_next,
821         .show  = cipso_seq_show,
822         .stop  = smk_seq_stop,
823 };
824
825 /**
826  * smk_open_cipso - open() for /smack/cipso
827  * @inode: inode structure representing file
828  * @file: "cipso" file pointer
829  *
830  * Connect our cipso_seq_* operations with /smack/cipso
831  * file_operations
832  */
833 static int smk_open_cipso(struct inode *inode, struct file *file)
834 {
835         return seq_open(file, &cipso_seq_ops);
836 }
837
838 /**
839  * smk_set_cipso - do the work for write() for cipso and cipso2
840  * @file: file pointer, not actually used
841  * @buf: where to get the data from
842  * @count: bytes sent
843  * @ppos: where to start
844  * @format: /smack/cipso or /smack/cipso2
845  *
846  * Accepts only one cipso rule per write call.
847  * Returns number of bytes written or error code, as appropriate
848  */
849 static ssize_t smk_set_cipso(struct file *file, const char __user *buf,
850                                 size_t count, loff_t *ppos, int format)
851 {
852         struct smack_known *skp;
853         struct netlbl_lsm_secattr ncats;
854         char mapcatset[SMK_CIPSOLEN];
855         int maplevel;
856         unsigned int cat;
857         int catlen;
858         ssize_t rc = -EINVAL;
859         char *data = NULL;
860         char *rule;
861         int ret;
862         int i;
863
864         /*
865          * Must have privilege.
866          * No partial writes.
867          * Enough data must be present.
868          */
869         if (!smack_privileged(CAP_MAC_ADMIN))
870                 return -EPERM;
871         if (*ppos != 0)
872                 return -EINVAL;
873         if (format == SMK_FIXED24_FMT &&
874             (count < SMK_CIPSOMIN || count > SMK_CIPSOMAX))
875                 return -EINVAL;
876
877         data = kzalloc(count + 1, GFP_KERNEL);
878         if (data == NULL)
879                 return -ENOMEM;
880
881         if (copy_from_user(data, buf, count) != 0) {
882                 rc = -EFAULT;
883                 goto unlockedout;
884         }
885
886         data[count] = '\0';
887         rule = data;
888         /*
889          * Only allow one writer at a time. Writes should be
890          * quite rare and small in any case.
891          */
892         mutex_lock(&smack_cipso_lock);
893
894         skp = smk_import_entry(rule, 0);
895         if (skp == NULL)
896                 goto out;
897
898         if (format == SMK_FIXED24_FMT)
899                 rule += SMK_LABELLEN;
900         else
901                 rule += strlen(skp->smk_known) + 1;
902
903         ret = sscanf(rule, "%d", &maplevel);
904         if (ret != 1 || maplevel > SMACK_CIPSO_MAXLEVEL)
905                 goto out;
906
907         rule += SMK_DIGITLEN;
908         ret = sscanf(rule, "%d", &catlen);
909         if (ret != 1 || catlen > SMACK_CIPSO_MAXCATNUM)
910                 goto out;
911
912         if (format == SMK_FIXED24_FMT &&
913             count != (SMK_CIPSOMIN + catlen * SMK_DIGITLEN))
914                 goto out;
915
916         memset(mapcatset, 0, sizeof(mapcatset));
917
918         for (i = 0; i < catlen; i++) {
919                 rule += SMK_DIGITLEN;
920                 ret = sscanf(rule, "%u", &cat);
921                 if (ret != 1 || cat > SMACK_CIPSO_MAXCATNUM)
922                         goto out;
923
924                 smack_catset_bit(cat, mapcatset);
925         }
926
927         rc = smk_netlbl_mls(maplevel, mapcatset, &ncats, SMK_CIPSOLEN);
928         if (rc >= 0) {
929                 netlbl_catmap_free(skp->smk_netlabel.attr.mls.cat);
930                 skp->smk_netlabel.attr.mls.cat = ncats.attr.mls.cat;
931                 skp->smk_netlabel.attr.mls.lvl = ncats.attr.mls.lvl;
932                 rc = count;
933         }
934
935 out:
936         mutex_unlock(&smack_cipso_lock);
937 unlockedout:
938         kfree(data);
939         return rc;
940 }
941
942 /**
943  * smk_write_cipso - write() for /smack/cipso
944  * @file: file pointer, not actually used
945  * @buf: where to get the data from
946  * @count: bytes sent
947  * @ppos: where to start
948  *
949  * Accepts only one cipso rule per write call.
950  * Returns number of bytes written or error code, as appropriate
951  */
952 static ssize_t smk_write_cipso(struct file *file, const char __user *buf,
953                                size_t count, loff_t *ppos)
954 {
955         return smk_set_cipso(file, buf, count, ppos, SMK_FIXED24_FMT);
956 }
957
958 static const struct file_operations smk_cipso_ops = {
959         .open           = smk_open_cipso,
960         .read           = seq_read,
961         .llseek         = seq_lseek,
962         .write          = smk_write_cipso,
963         .release        = seq_release,
964 };
965
966 /*
967  * Seq_file read operations for /smack/cipso2
968  */
969
970 /*
971  * Print cipso labels in format:
972  * label level[/cat[,cat]]
973  */
974 static int cipso2_seq_show(struct seq_file *s, void *v)
975 {
976         struct list_head  *list = v;
977         struct smack_known *skp =
978                  list_entry(list, struct smack_known, list);
979         struct netlbl_lsm_catmap *cmp = skp->smk_netlabel.attr.mls.cat;
980         char sep = '/';
981         int i;
982
983         seq_printf(s, "%s %3d", skp->smk_known, skp->smk_netlabel.attr.mls.lvl);
984
985         for (i = netlbl_catmap_walk(cmp, 0); i >= 0;
986              i = netlbl_catmap_walk(cmp, i + 1)) {
987                 seq_printf(s, "%c%d", sep, i);
988                 sep = ',';
989         }
990
991         seq_putc(s, '\n');
992
993         return 0;
994 }
995
996 static const struct seq_operations cipso2_seq_ops = {
997         .start = cipso_seq_start,
998         .next  = cipso_seq_next,
999         .show  = cipso2_seq_show,
1000         .stop  = smk_seq_stop,
1001 };
1002
1003 /**
1004  * smk_open_cipso2 - open() for /smack/cipso2
1005  * @inode: inode structure representing file
1006  * @file: "cipso2" file pointer
1007  *
1008  * Connect our cipso_seq_* operations with /smack/cipso2
1009  * file_operations
1010  */
1011 static int smk_open_cipso2(struct inode *inode, struct file *file)
1012 {
1013         return seq_open(file, &cipso2_seq_ops);
1014 }
1015
1016 /**
1017  * smk_write_cipso2 - write() for /smack/cipso2
1018  * @file: file pointer, not actually used
1019  * @buf: where to get the data from
1020  * @count: bytes sent
1021  * @ppos: where to start
1022  *
1023  * Accepts only one cipso rule per write call.
1024  * Returns number of bytes written or error code, as appropriate
1025  */
1026 static ssize_t smk_write_cipso2(struct file *file, const char __user *buf,
1027                               size_t count, loff_t *ppos)
1028 {
1029         return smk_set_cipso(file, buf, count, ppos, SMK_LONG_FMT);
1030 }
1031
1032 static const struct file_operations smk_cipso2_ops = {
1033         .open           = smk_open_cipso2,
1034         .read           = seq_read,
1035         .llseek         = seq_lseek,
1036         .write          = smk_write_cipso2,
1037         .release        = seq_release,
1038 };
1039
1040 /*
1041  * Seq_file read operations for /smack/netlabel
1042  */
1043
1044 static void *netlbladdr_seq_start(struct seq_file *s, loff_t *pos)
1045 {
1046         return smk_seq_start(s, pos, &smk_netlbladdr_list);
1047 }
1048
1049 static void *netlbladdr_seq_next(struct seq_file *s, void *v, loff_t *pos)
1050 {
1051         return smk_seq_next(s, v, pos, &smk_netlbladdr_list);
1052 }
1053 #define BEBITS  (sizeof(__be32) * 8)
1054
1055 /*
1056  * Print host/label pairs
1057  */
1058 static int netlbladdr_seq_show(struct seq_file *s, void *v)
1059 {
1060         struct list_head *list = v;
1061         struct smk_netlbladdr *skp =
1062                          list_entry(list, struct smk_netlbladdr, list);
1063         unsigned char *hp = (char *) &skp->smk_host.sin_addr.s_addr;
1064         int maskn;
1065         u32 temp_mask = be32_to_cpu(skp->smk_mask.s_addr);
1066
1067         for (maskn = 0; temp_mask; temp_mask <<= 1, maskn++);
1068
1069         seq_printf(s, "%u.%u.%u.%u/%d %s\n",
1070                 hp[0], hp[1], hp[2], hp[3], maskn, skp->smk_label);
1071
1072         return 0;
1073 }
1074
1075 static const struct seq_operations netlbladdr_seq_ops = {
1076         .start = netlbladdr_seq_start,
1077         .next  = netlbladdr_seq_next,
1078         .show  = netlbladdr_seq_show,
1079         .stop  = smk_seq_stop,
1080 };
1081
1082 /**
1083  * smk_open_netlbladdr - open() for /smack/netlabel
1084  * @inode: inode structure representing file
1085  * @file: "netlabel" file pointer
1086  *
1087  * Connect our netlbladdr_seq_* operations with /smack/netlabel
1088  * file_operations
1089  */
1090 static int smk_open_netlbladdr(struct inode *inode, struct file *file)
1091 {
1092         return seq_open(file, &netlbladdr_seq_ops);
1093 }
1094
1095 /**
1096  * smk_netlbladdr_insert
1097  * @new : netlabel to insert
1098  *
1099  * This helper insert netlabel in the smack_netlbladdrs list
1100  * sorted by netmask length (longest to smallest)
1101  * locked by &smk_netlbladdr_lock in smk_write_netlbladdr
1102  *
1103  */
1104 static void smk_netlbladdr_insert(struct smk_netlbladdr *new)
1105 {
1106         struct smk_netlbladdr *m, *m_next;
1107
1108         if (list_empty(&smk_netlbladdr_list)) {
1109                 list_add_rcu(&new->list, &smk_netlbladdr_list);
1110                 return;
1111         }
1112
1113         m = list_entry_rcu(smk_netlbladdr_list.next,
1114                            struct smk_netlbladdr, list);
1115
1116         /* the comparison '>' is a bit hacky, but works */
1117         if (new->smk_mask.s_addr > m->smk_mask.s_addr) {
1118                 list_add_rcu(&new->list, &smk_netlbladdr_list);
1119                 return;
1120         }
1121
1122         list_for_each_entry_rcu(m, &smk_netlbladdr_list, list) {
1123                 if (list_is_last(&m->list, &smk_netlbladdr_list)) {
1124                         list_add_rcu(&new->list, &m->list);
1125                         return;
1126                 }
1127                 m_next = list_entry_rcu(m->list.next,
1128                                         struct smk_netlbladdr, list);
1129                 if (new->smk_mask.s_addr > m_next->smk_mask.s_addr) {
1130                         list_add_rcu(&new->list, &m->list);
1131                         return;
1132                 }
1133         }
1134 }
1135
1136
1137 /**
1138  * smk_write_netlbladdr - write() for /smack/netlabel
1139  * @file: file pointer, not actually used
1140  * @buf: where to get the data from
1141  * @count: bytes sent
1142  * @ppos: where to start
1143  *
1144  * Accepts only one netlbladdr per write call.
1145  * Returns number of bytes written or error code, as appropriate
1146  */
1147 static ssize_t smk_write_netlbladdr(struct file *file, const char __user *buf,
1148                                 size_t count, loff_t *ppos)
1149 {
1150         struct smk_netlbladdr *skp;
1151         struct sockaddr_in newname;
1152         char *smack;
1153         char *sp;
1154         char *data;
1155         char *host = (char *)&newname.sin_addr.s_addr;
1156         int rc;
1157         struct netlbl_audit audit_info;
1158         struct in_addr mask;
1159         unsigned int m;
1160         int found;
1161         u32 mask_bits = (1<<31);
1162         __be32 nsa;
1163         u32 temp_mask;
1164
1165         /*
1166          * Must have privilege.
1167          * No partial writes.
1168          * Enough data must be present.
1169          * "<addr/mask, as a.b.c.d/e><space><label>"
1170          * "<addr, as a.b.c.d><space><label>"
1171          */
1172         if (!smack_privileged(CAP_MAC_ADMIN))
1173                 return -EPERM;
1174         if (*ppos != 0)
1175                 return -EINVAL;
1176         if (count < SMK_NETLBLADDRMIN)
1177                 return -EINVAL;
1178
1179         data = kzalloc(count + 1, GFP_KERNEL);
1180         if (data == NULL)
1181                 return -ENOMEM;
1182
1183         if (copy_from_user(data, buf, count) != 0) {
1184                 rc = -EFAULT;
1185                 goto free_data_out;
1186         }
1187
1188         smack = kzalloc(count + 1, GFP_KERNEL);
1189         if (smack == NULL) {
1190                 rc = -ENOMEM;
1191                 goto free_data_out;
1192         }
1193
1194         data[count] = '\0';
1195
1196         rc = sscanf(data, "%hhd.%hhd.%hhd.%hhd/%u %s",
1197                 &host[0], &host[1], &host[2], &host[3], &m, smack);
1198         if (rc != 6) {
1199                 rc = sscanf(data, "%hhd.%hhd.%hhd.%hhd %s",
1200                         &host[0], &host[1], &host[2], &host[3], smack);
1201                 if (rc != 5) {
1202                         rc = -EINVAL;
1203                         goto free_out;
1204                 }
1205                 m = BEBITS;
1206         }
1207         if (m > BEBITS) {
1208                 rc = -EINVAL;
1209                 goto free_out;
1210         }
1211
1212         /*
1213          * If smack begins with '-', it is an option, don't import it
1214          */
1215         if (smack[0] != '-') {
1216                 sp = smk_import(smack, 0);
1217                 if (sp == NULL) {
1218                         rc = -EINVAL;
1219                         goto free_out;
1220                 }
1221         } else {
1222                 /* check known options */
1223                 if (strcmp(smack, smack_cipso_option) == 0)
1224                         sp = (char *)smack_cipso_option;
1225                 else {
1226                         rc = -EINVAL;
1227                         goto free_out;
1228                 }
1229         }
1230
1231         for (temp_mask = 0; m > 0; m--) {
1232                 temp_mask |= mask_bits;
1233                 mask_bits >>= 1;
1234         }
1235         mask.s_addr = cpu_to_be32(temp_mask);
1236
1237         newname.sin_addr.s_addr &= mask.s_addr;
1238         /*
1239          * Only allow one writer at a time. Writes should be
1240          * quite rare and small in any case.
1241          */
1242         mutex_lock(&smk_netlbladdr_lock);
1243
1244         nsa = newname.sin_addr.s_addr;
1245         /* try to find if the prefix is already in the list */
1246         found = 0;
1247         list_for_each_entry_rcu(skp, &smk_netlbladdr_list, list) {
1248                 if (skp->smk_host.sin_addr.s_addr == nsa &&
1249                     skp->smk_mask.s_addr == mask.s_addr) {
1250                         found = 1;
1251                         break;
1252                 }
1253         }
1254         smk_netlabel_audit_set(&audit_info);
1255
1256         if (found == 0) {
1257                 skp = kzalloc(sizeof(*skp), GFP_KERNEL);
1258                 if (skp == NULL)
1259                         rc = -ENOMEM;
1260                 else {
1261                         rc = 0;
1262                         skp->smk_host.sin_addr.s_addr = newname.sin_addr.s_addr;
1263                         skp->smk_mask.s_addr = mask.s_addr;
1264                         skp->smk_label = sp;
1265                         smk_netlbladdr_insert(skp);
1266                 }
1267         } else {
1268                 /* we delete the unlabeled entry, only if the previous label
1269                  * wasn't the special CIPSO option */
1270                 if (skp->smk_label != smack_cipso_option)
1271                         rc = netlbl_cfg_unlbl_static_del(&init_net, NULL,
1272                                         &skp->smk_host.sin_addr, &skp->smk_mask,
1273                                         PF_INET, &audit_info);
1274                 else
1275                         rc = 0;
1276                 skp->smk_label = sp;
1277         }
1278
1279         /*
1280          * Now tell netlabel about the single label nature of
1281          * this host so that incoming packets get labeled.
1282          * but only if we didn't get the special CIPSO option
1283          */
1284         if (rc == 0 && sp != smack_cipso_option)
1285                 rc = netlbl_cfg_unlbl_static_add(&init_net, NULL,
1286                         &skp->smk_host.sin_addr, &skp->smk_mask, PF_INET,
1287                         smack_to_secid(skp->smk_label), &audit_info);
1288
1289         if (rc == 0)
1290                 rc = count;
1291
1292         mutex_unlock(&smk_netlbladdr_lock);
1293
1294 free_out:
1295         kfree(smack);
1296 free_data_out:
1297         kfree(data);
1298
1299         return rc;
1300 }
1301
1302 static const struct file_operations smk_netlbladdr_ops = {
1303         .open           = smk_open_netlbladdr,
1304         .read           = seq_read,
1305         .llseek         = seq_lseek,
1306         .write          = smk_write_netlbladdr,
1307         .release        = seq_release,
1308 };
1309
1310 /**
1311  * smk_read_doi - read() for /smack/doi
1312  * @filp: file pointer, not actually used
1313  * @buf: where to put the result
1314  * @count: maximum to send along
1315  * @ppos: where to start
1316  *
1317  * Returns number of bytes read or error code, as appropriate
1318  */
1319 static ssize_t smk_read_doi(struct file *filp, char __user *buf,
1320                             size_t count, loff_t *ppos)
1321 {
1322         char temp[80];
1323         ssize_t rc;
1324
1325         if (*ppos != 0)
1326                 return 0;
1327
1328         sprintf(temp, "%d", smk_cipso_doi_value);
1329         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
1330
1331         return rc;
1332 }
1333
1334 /**
1335  * smk_write_doi - write() for /smack/doi
1336  * @file: file pointer, not actually used
1337  * @buf: where to get the data from
1338  * @count: bytes sent
1339  * @ppos: where to start
1340  *
1341  * Returns number of bytes written or error code, as appropriate
1342  */
1343 static ssize_t smk_write_doi(struct file *file, const char __user *buf,
1344                              size_t count, loff_t *ppos)
1345 {
1346         char temp[80];
1347         int i;
1348
1349         if (!smack_privileged(CAP_MAC_ADMIN))
1350                 return -EPERM;
1351
1352         if (count >= sizeof(temp) || count == 0)
1353                 return -EINVAL;
1354
1355         if (copy_from_user(temp, buf, count) != 0)
1356                 return -EFAULT;
1357
1358         temp[count] = '\0';
1359
1360         if (sscanf(temp, "%d", &i) != 1)
1361                 return -EINVAL;
1362
1363         smk_cipso_doi_value = i;
1364
1365         smk_cipso_doi();
1366
1367         return count;
1368 }
1369
1370 static const struct file_operations smk_doi_ops = {
1371         .read           = smk_read_doi,
1372         .write          = smk_write_doi,
1373         .llseek         = default_llseek,
1374 };
1375
1376 /**
1377  * smk_read_direct - read() for /smack/direct
1378  * @filp: file pointer, not actually used
1379  * @buf: where to put the result
1380  * @count: maximum to send along
1381  * @ppos: where to start
1382  *
1383  * Returns number of bytes read or error code, as appropriate
1384  */
1385 static ssize_t smk_read_direct(struct file *filp, char __user *buf,
1386                                size_t count, loff_t *ppos)
1387 {
1388         char temp[80];
1389         ssize_t rc;
1390
1391         if (*ppos != 0)
1392                 return 0;
1393
1394         sprintf(temp, "%d", smack_cipso_direct);
1395         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
1396
1397         return rc;
1398 }
1399
1400 /**
1401  * smk_write_direct - write() for /smack/direct
1402  * @file: file pointer, not actually used
1403  * @buf: where to get the data from
1404  * @count: bytes sent
1405  * @ppos: where to start
1406  *
1407  * Returns number of bytes written or error code, as appropriate
1408  */
1409 static ssize_t smk_write_direct(struct file *file, const char __user *buf,
1410                                 size_t count, loff_t *ppos)
1411 {
1412         struct smack_known *skp;
1413         char temp[80];
1414         int i;
1415
1416         if (!smack_privileged(CAP_MAC_ADMIN))
1417                 return -EPERM;
1418
1419         if (count >= sizeof(temp) || count == 0)
1420                 return -EINVAL;
1421
1422         if (copy_from_user(temp, buf, count) != 0)
1423                 return -EFAULT;
1424
1425         temp[count] = '\0';
1426
1427         if (sscanf(temp, "%d", &i) != 1)
1428                 return -EINVAL;
1429
1430         /*
1431          * Don't do anything if the value hasn't actually changed.
1432          * If it is changing reset the level on entries that were
1433          * set up to be direct when they were created.
1434          */
1435         if (smack_cipso_direct != i) {
1436                 mutex_lock(&smack_known_lock);
1437                 list_for_each_entry_rcu(skp, &smack_known_list, list)
1438                         if (skp->smk_netlabel.attr.mls.lvl ==
1439                             smack_cipso_direct)
1440                                 skp->smk_netlabel.attr.mls.lvl = i;
1441                 smack_cipso_direct = i;
1442                 mutex_unlock(&smack_known_lock);
1443         }
1444
1445         return count;
1446 }
1447
1448 static const struct file_operations smk_direct_ops = {
1449         .read           = smk_read_direct,
1450         .write          = smk_write_direct,
1451         .llseek         = default_llseek,
1452 };
1453
1454 /**
1455  * smk_read_mapped - read() for /smack/mapped
1456  * @filp: file pointer, not actually used
1457  * @buf: where to put the result
1458  * @count: maximum to send along
1459  * @ppos: where to start
1460  *
1461  * Returns number of bytes read or error code, as appropriate
1462  */
1463 static ssize_t smk_read_mapped(struct file *filp, char __user *buf,
1464                                size_t count, loff_t *ppos)
1465 {
1466         char temp[80];
1467         ssize_t rc;
1468
1469         if (*ppos != 0)
1470                 return 0;
1471
1472         sprintf(temp, "%d", smack_cipso_mapped);
1473         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
1474
1475         return rc;
1476 }
1477
1478 /**
1479  * smk_write_mapped - write() for /smack/mapped
1480  * @file: file pointer, not actually used
1481  * @buf: where to get the data from
1482  * @count: bytes sent
1483  * @ppos: where to start
1484  *
1485  * Returns number of bytes written or error code, as appropriate
1486  */
1487 static ssize_t smk_write_mapped(struct file *file, const char __user *buf,
1488                                 size_t count, loff_t *ppos)
1489 {
1490         struct smack_known *skp;
1491         char temp[80];
1492         int i;
1493
1494         if (!smack_privileged(CAP_MAC_ADMIN))
1495                 return -EPERM;
1496
1497         if (count >= sizeof(temp) || count == 0)
1498                 return -EINVAL;
1499
1500         if (copy_from_user(temp, buf, count) != 0)
1501                 return -EFAULT;
1502
1503         temp[count] = '\0';
1504
1505         if (sscanf(temp, "%d", &i) != 1)
1506                 return -EINVAL;
1507
1508         /*
1509          * Don't do anything if the value hasn't actually changed.
1510          * If it is changing reset the level on entries that were
1511          * set up to be mapped when they were created.
1512          */
1513         if (smack_cipso_mapped != i) {
1514                 mutex_lock(&smack_known_lock);
1515                 list_for_each_entry_rcu(skp, &smack_known_list, list)
1516                         if (skp->smk_netlabel.attr.mls.lvl ==
1517                             smack_cipso_mapped)
1518                                 skp->smk_netlabel.attr.mls.lvl = i;
1519                 smack_cipso_mapped = i;
1520                 mutex_unlock(&smack_known_lock);
1521         }
1522
1523         return count;
1524 }
1525
1526 static const struct file_operations smk_mapped_ops = {
1527         .read           = smk_read_mapped,
1528         .write          = smk_write_mapped,
1529         .llseek         = default_llseek,
1530 };
1531
1532 /**
1533  * smk_read_ambient - read() for /smack/ambient
1534  * @filp: file pointer, not actually used
1535  * @buf: where to put the result
1536  * @cn: maximum to send along
1537  * @ppos: where to start
1538  *
1539  * Returns number of bytes read or error code, as appropriate
1540  */
1541 static ssize_t smk_read_ambient(struct file *filp, char __user *buf,
1542                                 size_t cn, loff_t *ppos)
1543 {
1544         ssize_t rc;
1545         int asize;
1546
1547         if (*ppos != 0)
1548                 return 0;
1549         /*
1550          * Being careful to avoid a problem in the case where
1551          * smack_net_ambient gets changed in midstream.
1552          */
1553         mutex_lock(&smack_ambient_lock);
1554
1555         asize = strlen(smack_net_ambient->smk_known) + 1;
1556
1557         if (cn >= asize)
1558                 rc = simple_read_from_buffer(buf, cn, ppos,
1559                                              smack_net_ambient->smk_known,
1560                                              asize);
1561         else
1562                 rc = -EINVAL;
1563
1564         mutex_unlock(&smack_ambient_lock);
1565
1566         return rc;
1567 }
1568
1569 /**
1570  * smk_write_ambient - write() for /smack/ambient
1571  * @file: file pointer, not actually used
1572  * @buf: where to get the data from
1573  * @count: bytes sent
1574  * @ppos: where to start
1575  *
1576  * Returns number of bytes written or error code, as appropriate
1577  */
1578 static ssize_t smk_write_ambient(struct file *file, const char __user *buf,
1579                                  size_t count, loff_t *ppos)
1580 {
1581         struct smack_known *skp;
1582         char *oldambient;
1583         char *data;
1584         int rc = count;
1585
1586         if (!smack_privileged(CAP_MAC_ADMIN))
1587                 return -EPERM;
1588
1589         data = kzalloc(count + 1, GFP_KERNEL);
1590         if (data == NULL)
1591                 return -ENOMEM;
1592
1593         if (copy_from_user(data, buf, count) != 0) {
1594                 rc = -EFAULT;
1595                 goto out;
1596         }
1597
1598         skp = smk_import_entry(data, count);
1599         if (skp == NULL) {
1600                 rc = -EINVAL;
1601                 goto out;
1602         }
1603
1604         mutex_lock(&smack_ambient_lock);
1605
1606         oldambient = smack_net_ambient->smk_known;
1607         smack_net_ambient = skp;
1608         smk_unlbl_ambient(oldambient);
1609
1610         mutex_unlock(&smack_ambient_lock);
1611
1612 out:
1613         kfree(data);
1614         return rc;
1615 }
1616
1617 static const struct file_operations smk_ambient_ops = {
1618         .read           = smk_read_ambient,
1619         .write          = smk_write_ambient,
1620         .llseek         = default_llseek,
1621 };
1622
1623 /**
1624  * smk_read_onlycap - read() for smackfs/onlycap
1625  * @filp: file pointer, not actually used
1626  * @buf: where to put the result
1627  * @cn: maximum to send along
1628  * @ppos: where to start
1629  *
1630  * Returns number of bytes read or error code, as appropriate
1631  */
1632 static ssize_t smk_read_onlycap(struct file *filp, char __user *buf,
1633                                 size_t cn, loff_t *ppos)
1634 {
1635         char *smack = "";
1636         ssize_t rc = -EINVAL;
1637         int asize;
1638
1639         if (*ppos != 0)
1640                 return 0;
1641
1642         if (smack_onlycap != NULL)
1643                 smack = smack_onlycap->smk_known;
1644
1645         asize = strlen(smack) + 1;
1646
1647         if (cn >= asize)
1648                 rc = simple_read_from_buffer(buf, cn, ppos, smack, asize);
1649
1650         return rc;
1651 }
1652
1653 /**
1654  * smk_write_onlycap - write() for smackfs/onlycap
1655  * @file: file pointer, not actually used
1656  * @buf: where to get the data from
1657  * @count: bytes sent
1658  * @ppos: where to start
1659  *
1660  * Returns number of bytes written or error code, as appropriate
1661  */
1662 static ssize_t smk_write_onlycap(struct file *file, const char __user *buf,
1663                                  size_t count, loff_t *ppos)
1664 {
1665         char *data;
1666         struct smack_known *skp = smk_of_task(current->cred->security);
1667         int rc = count;
1668
1669         if (!smack_privileged(CAP_MAC_ADMIN))
1670                 return -EPERM;
1671
1672         /*
1673          * This can be done using smk_access() but is done
1674          * explicitly for clarity. The smk_access() implementation
1675          * would use smk_access(smack_onlycap, MAY_WRITE)
1676          */
1677         if (smack_onlycap != NULL && smack_onlycap != skp)
1678                 return -EPERM;
1679
1680         data = kzalloc(count, GFP_KERNEL);
1681         if (data == NULL)
1682                 return -ENOMEM;
1683
1684         /*
1685          * Should the null string be passed in unset the onlycap value.
1686          * This seems like something to be careful with as usually
1687          * smk_import only expects to return NULL for errors. It
1688          * is usually the case that a nullstring or "\n" would be
1689          * bad to pass to smk_import but in fact this is useful here.
1690          *
1691          * smk_import will also reject a label beginning with '-',
1692          * so "-usecapabilities" will also work.
1693          */
1694         if (copy_from_user(data, buf, count) != 0)
1695                 rc = -EFAULT;
1696         else
1697                 smack_onlycap = smk_import_entry(data, count);
1698
1699         kfree(data);
1700         return rc;
1701 }
1702
1703 static const struct file_operations smk_onlycap_ops = {
1704         .read           = smk_read_onlycap,
1705         .write          = smk_write_onlycap,
1706         .llseek         = default_llseek,
1707 };
1708
1709 /**
1710  * smk_read_logging - read() for /smack/logging
1711  * @filp: file pointer, not actually used
1712  * @buf: where to put the result
1713  * @cn: maximum to send along
1714  * @ppos: where to start
1715  *
1716  * Returns number of bytes read or error code, as appropriate
1717  */
1718 static ssize_t smk_read_logging(struct file *filp, char __user *buf,
1719                                 size_t count, loff_t *ppos)
1720 {
1721         char temp[32];
1722         ssize_t rc;
1723
1724         if (*ppos != 0)
1725                 return 0;
1726
1727         sprintf(temp, "%d\n", log_policy);
1728         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
1729         return rc;
1730 }
1731
1732 /**
1733  * smk_write_logging - write() for /smack/logging
1734  * @file: file pointer, not actually used
1735  * @buf: where to get the data from
1736  * @count: bytes sent
1737  * @ppos: where to start
1738  *
1739  * Returns number of bytes written or error code, as appropriate
1740  */
1741 static ssize_t smk_write_logging(struct file *file, const char __user *buf,
1742                                 size_t count, loff_t *ppos)
1743 {
1744         char temp[32];
1745         int i;
1746
1747         if (!smack_privileged(CAP_MAC_ADMIN))
1748                 return -EPERM;
1749
1750         if (count >= sizeof(temp) || count == 0)
1751                 return -EINVAL;
1752
1753         if (copy_from_user(temp, buf, count) != 0)
1754                 return -EFAULT;
1755
1756         temp[count] = '\0';
1757
1758         if (sscanf(temp, "%d", &i) != 1)
1759                 return -EINVAL;
1760         if (i < 0 || i > 3)
1761                 return -EINVAL;
1762         log_policy = i;
1763         return count;
1764 }
1765
1766
1767
1768 static const struct file_operations smk_logging_ops = {
1769         .read           = smk_read_logging,
1770         .write          = smk_write_logging,
1771         .llseek         = default_llseek,
1772 };
1773
1774 /*
1775  * Seq_file read operations for /smack/load-self
1776  */
1777
1778 static void *load_self_seq_start(struct seq_file *s, loff_t *pos)
1779 {
1780         struct task_smack *tsp = current_security();
1781
1782         return smk_seq_start(s, pos, &tsp->smk_rules);
1783 }
1784
1785 static void *load_self_seq_next(struct seq_file *s, void *v, loff_t *pos)
1786 {
1787         struct task_smack *tsp = current_security();
1788
1789         return smk_seq_next(s, v, pos, &tsp->smk_rules);
1790 }
1791
1792 static int load_self_seq_show(struct seq_file *s, void *v)
1793 {
1794         struct list_head *list = v;
1795         struct smack_rule *srp =
1796                  list_entry(list, struct smack_rule, list);
1797
1798         smk_rule_show(s, srp, SMK_LABELLEN);
1799
1800         return 0;
1801 }
1802
1803 static const struct seq_operations load_self_seq_ops = {
1804         .start = load_self_seq_start,
1805         .next  = load_self_seq_next,
1806         .show  = load_self_seq_show,
1807         .stop  = smk_seq_stop,
1808 };
1809
1810
1811 /**
1812  * smk_open_load_self - open() for /smack/load-self2
1813  * @inode: inode structure representing file
1814  * @file: "load" file pointer
1815  *
1816  * For reading, use load_seq_* seq_file reading operations.
1817  */
1818 static int smk_open_load_self(struct inode *inode, struct file *file)
1819 {
1820         return seq_open(file, &load_self_seq_ops);
1821 }
1822
1823 /**
1824  * smk_write_load_self - write() for /smack/load-self
1825  * @file: file pointer, not actually used
1826  * @buf: where to get the data from
1827  * @count: bytes sent
1828  * @ppos: where to start - must be 0
1829  *
1830  */
1831 static ssize_t smk_write_load_self(struct file *file, const char __user *buf,
1832                               size_t count, loff_t *ppos)
1833 {
1834         struct task_smack *tsp = current_security();
1835
1836         return smk_write_rules_list(file, buf, count, ppos, &tsp->smk_rules,
1837                                     &tsp->smk_rules_lock, SMK_FIXED24_FMT);
1838 }
1839
1840 static const struct file_operations smk_load_self_ops = {
1841         .open           = smk_open_load_self,
1842         .read           = seq_read,
1843         .llseek         = seq_lseek,
1844         .write          = smk_write_load_self,
1845         .release        = seq_release,
1846 };
1847
1848 /**
1849  * smk_user_access - handle access check transaction
1850  * @file: file pointer
1851  * @buf: data from user space
1852  * @count: bytes sent
1853  * @ppos: where to start - must be 0
1854  */
1855 static ssize_t smk_user_access(struct file *file, const char __user *buf,
1856                                 size_t count, loff_t *ppos, int format)
1857 {
1858         struct smack_parsed_rule rule;
1859         char *data;
1860         int res;
1861
1862         data = simple_transaction_get(file, buf, count);
1863         if (IS_ERR(data))
1864                 return PTR_ERR(data);
1865
1866         if (format == SMK_FIXED24_FMT) {
1867                 if (count < SMK_LOADLEN)
1868                         return -EINVAL;
1869                 res = smk_parse_rule(data, &rule, 0);
1870         } else {
1871                 /*
1872                  * simple_transaction_get() returns null-terminated data
1873                  */
1874                 res = smk_parse_long_rule(data, &rule, 0, 3);
1875         }
1876
1877         if (res >= 0)
1878                 res = smk_access(rule.smk_subject, rule.smk_object,
1879                                  rule.smk_access1, NULL);
1880         else if (res != -ENOENT)
1881                 return -EINVAL;
1882
1883         data[0] = res == 0 ? '1' : '0';
1884         data[1] = '\0';
1885
1886         simple_transaction_set(file, 2);
1887
1888         if (format == SMK_FIXED24_FMT)
1889                 return SMK_LOADLEN;
1890         return count;
1891 }
1892
1893 /**
1894  * smk_write_access - handle access check transaction
1895  * @file: file pointer
1896  * @buf: data from user space
1897  * @count: bytes sent
1898  * @ppos: where to start - must be 0
1899  */
1900 static ssize_t smk_write_access(struct file *file, const char __user *buf,
1901                                 size_t count, loff_t *ppos)
1902 {
1903         return smk_user_access(file, buf, count, ppos, SMK_FIXED24_FMT);
1904 }
1905
1906 static const struct file_operations smk_access_ops = {
1907         .write          = smk_write_access,
1908         .read           = simple_transaction_read,
1909         .release        = simple_transaction_release,
1910         .llseek         = generic_file_llseek,
1911 };
1912
1913
1914 /*
1915  * Seq_file read operations for /smack/load2
1916  */
1917
1918 static int load2_seq_show(struct seq_file *s, void *v)
1919 {
1920         struct list_head *list = v;
1921         struct smack_master_list *smlp =
1922                  list_entry(list, struct smack_master_list, list);
1923
1924         smk_rule_show(s, smlp->smk_rule, SMK_LONGLABEL);
1925
1926         return 0;
1927 }
1928
1929 static const struct seq_operations load2_seq_ops = {
1930         .start = load2_seq_start,
1931         .next  = load2_seq_next,
1932         .show  = load2_seq_show,
1933         .stop  = smk_seq_stop,
1934 };
1935
1936 /**
1937  * smk_open_load2 - open() for /smack/load2
1938  * @inode: inode structure representing file
1939  * @file: "load2" file pointer
1940  *
1941  * For reading, use load2_seq_* seq_file reading operations.
1942  */
1943 static int smk_open_load2(struct inode *inode, struct file *file)
1944 {
1945         return seq_open(file, &load2_seq_ops);
1946 }
1947
1948 /**
1949  * smk_write_load2 - write() for /smack/load2
1950  * @file: file pointer, not actually used
1951  * @buf: where to get the data from
1952  * @count: bytes sent
1953  * @ppos: where to start - must be 0
1954  *
1955  */
1956 static ssize_t smk_write_load2(struct file *file, const char __user *buf,
1957                                 size_t count, loff_t *ppos)
1958 {
1959         /*
1960          * Must have privilege.
1961          */
1962         if (!smack_privileged(CAP_MAC_ADMIN))
1963                 return -EPERM;
1964
1965         return smk_write_rules_list(file, buf, count, ppos, NULL, NULL,
1966                                     SMK_LONG_FMT);
1967 }
1968
1969 static const struct file_operations smk_load2_ops = {
1970         .open           = smk_open_load2,
1971         .read           = seq_read,
1972         .llseek         = seq_lseek,
1973         .write          = smk_write_load2,
1974         .release        = seq_release,
1975 };
1976
1977 /*
1978  * Seq_file read operations for /smack/load-self2
1979  */
1980
1981 static void *load_self2_seq_start(struct seq_file *s, loff_t *pos)
1982 {
1983         struct task_smack *tsp = current_security();
1984
1985         return smk_seq_start(s, pos, &tsp->smk_rules);
1986 }
1987
1988 static void *load_self2_seq_next(struct seq_file *s, void *v, loff_t *pos)
1989 {
1990         struct task_smack *tsp = current_security();
1991
1992         return smk_seq_next(s, v, pos, &tsp->smk_rules);
1993 }
1994
1995 static int load_self2_seq_show(struct seq_file *s, void *v)
1996 {
1997         struct list_head *list = v;
1998         struct smack_rule *srp =
1999                  list_entry(list, struct smack_rule, list);
2000
2001         smk_rule_show(s, srp, SMK_LONGLABEL);
2002
2003         return 0;
2004 }
2005
2006 static const struct seq_operations load_self2_seq_ops = {
2007         .start = load_self2_seq_start,
2008         .next  = load_self2_seq_next,
2009         .show  = load_self2_seq_show,
2010         .stop  = smk_seq_stop,
2011 };
2012
2013 /**
2014  * smk_open_load_self2 - open() for /smack/load-self2
2015  * @inode: inode structure representing file
2016  * @file: "load" file pointer
2017  *
2018  * For reading, use load_seq_* seq_file reading operations.
2019  */
2020 static int smk_open_load_self2(struct inode *inode, struct file *file)
2021 {
2022         return seq_open(file, &load_self2_seq_ops);
2023 }
2024
2025 /**
2026  * smk_write_load_self2 - write() for /smack/load-self2
2027  * @file: file pointer, not actually used
2028  * @buf: where to get the data from
2029  * @count: bytes sent
2030  * @ppos: where to start - must be 0
2031  *
2032  */
2033 static ssize_t smk_write_load_self2(struct file *file, const char __user *buf,
2034                               size_t count, loff_t *ppos)
2035 {
2036         struct task_smack *tsp = current_security();
2037
2038         return smk_write_rules_list(file, buf, count, ppos, &tsp->smk_rules,
2039                                     &tsp->smk_rules_lock, SMK_LONG_FMT);
2040 }
2041
2042 static const struct file_operations smk_load_self2_ops = {
2043         .open           = smk_open_load_self2,
2044         .read           = seq_read,
2045         .llseek         = seq_lseek,
2046         .write          = smk_write_load_self2,
2047         .release        = seq_release,
2048 };
2049
2050 /**
2051  * smk_write_access2 - handle access check transaction
2052  * @file: file pointer
2053  * @buf: data from user space
2054  * @count: bytes sent
2055  * @ppos: where to start - must be 0
2056  */
2057 static ssize_t smk_write_access2(struct file *file, const char __user *buf,
2058                                         size_t count, loff_t *ppos)
2059 {
2060         return smk_user_access(file, buf, count, ppos, SMK_LONG_FMT);
2061 }
2062
2063 static const struct file_operations smk_access2_ops = {
2064         .write          = smk_write_access2,
2065         .read           = simple_transaction_read,
2066         .release        = simple_transaction_release,
2067         .llseek         = generic_file_llseek,
2068 };
2069
2070 /**
2071  * smk_write_revoke_subj - write() for /smack/revoke-subject
2072  * @file: file pointer
2073  * @buf: data from user space
2074  * @count: bytes sent
2075  * @ppos: where to start - must be 0
2076  */
2077 static ssize_t smk_write_revoke_subj(struct file *file, const char __user *buf,
2078                                 size_t count, loff_t *ppos)
2079 {
2080         char *data = NULL;
2081         const char *cp = NULL;
2082         struct smack_known *skp;
2083         struct smack_rule *sp;
2084         struct list_head *rule_list;
2085         struct mutex *rule_lock;
2086         int rc = count;
2087
2088         if (*ppos != 0)
2089                 return -EINVAL;
2090
2091         if (!smack_privileged(CAP_MAC_ADMIN))
2092                 return -EPERM;
2093
2094         if (count == 0 || count > SMK_LONGLABEL)
2095                 return -EINVAL;
2096
2097         data = kzalloc(count, GFP_KERNEL);
2098         if (data == NULL)
2099                 return -ENOMEM;
2100
2101         if (copy_from_user(data, buf, count) != 0) {
2102                 rc = -EFAULT;
2103                 goto free_out;
2104         }
2105
2106         cp = smk_parse_smack(data, count);
2107         if (cp == NULL) {
2108                 rc = -EINVAL;
2109                 goto free_out;
2110         }
2111
2112         skp = smk_find_entry(cp);
2113         if (skp == NULL)
2114                 goto free_out;
2115
2116         rule_list = &skp->smk_rules;
2117         rule_lock = &skp->smk_rules_lock;
2118
2119         mutex_lock(rule_lock);
2120
2121         list_for_each_entry_rcu(sp, rule_list, list)
2122                 sp->smk_access = 0;
2123
2124         mutex_unlock(rule_lock);
2125
2126 free_out:
2127         kfree(data);
2128         kfree(cp);
2129         return rc;
2130 }
2131
2132 static const struct file_operations smk_revoke_subj_ops = {
2133         .write          = smk_write_revoke_subj,
2134         .read           = simple_transaction_read,
2135         .release        = simple_transaction_release,
2136         .llseek         = generic_file_llseek,
2137 };
2138
2139 static struct kset *smackfs_kset;
2140 /**
2141  * smk_init_sysfs - initialize /sys/fs/smackfs
2142  *
2143  */
2144 static int smk_init_sysfs(void)
2145 {
2146         smackfs_kset = kset_create_and_add("smackfs", NULL, fs_kobj);
2147         if (!smackfs_kset)
2148                 return -ENOMEM;
2149         return 0;
2150 }
2151
2152 /**
2153  * smk_write_change_rule - write() for /smack/change-rule
2154  * @file: file pointer
2155  * @buf: data from user space
2156  * @count: bytes sent
2157  * @ppos: where to start - must be 0
2158  */
2159 static ssize_t smk_write_change_rule(struct file *file, const char __user *buf,
2160                                 size_t count, loff_t *ppos)
2161 {
2162         /*
2163          * Must have privilege.
2164          */
2165         if (!smack_privileged(CAP_MAC_ADMIN))
2166                 return -EPERM;
2167
2168         return smk_write_rules_list(file, buf, count, ppos, NULL, NULL,
2169                                     SMK_CHANGE_FMT);
2170 }
2171
2172 static const struct file_operations smk_change_rule_ops = {
2173         .write          = smk_write_change_rule,
2174         .read           = simple_transaction_read,
2175         .release        = simple_transaction_release,
2176         .llseek         = generic_file_llseek,
2177 };
2178
2179 /**
2180  * smk_read_syslog - read() for smackfs/syslog
2181  * @filp: file pointer, not actually used
2182  * @buf: where to put the result
2183  * @cn: maximum to send along
2184  * @ppos: where to start
2185  *
2186  * Returns number of bytes read or error code, as appropriate
2187  */
2188 static ssize_t smk_read_syslog(struct file *filp, char __user *buf,
2189                                 size_t cn, loff_t *ppos)
2190 {
2191         struct smack_known *skp;
2192         ssize_t rc = -EINVAL;
2193         int asize;
2194
2195         if (*ppos != 0)
2196                 return 0;
2197
2198         if (smack_syslog_label == NULL)
2199                 skp = &smack_known_star;
2200         else
2201                 skp = smack_syslog_label;
2202
2203         asize = strlen(skp->smk_known) + 1;
2204
2205         if (cn >= asize)
2206                 rc = simple_read_from_buffer(buf, cn, ppos, skp->smk_known,
2207                                                 asize);
2208
2209         return rc;
2210 }
2211
2212 /**
2213  * smk_write_syslog - write() for smackfs/syslog
2214  * @file: file pointer, not actually used
2215  * @buf: where to get the data from
2216  * @count: bytes sent
2217  * @ppos: where to start
2218  *
2219  * Returns number of bytes written or error code, as appropriate
2220  */
2221 static ssize_t smk_write_syslog(struct file *file, const char __user *buf,
2222                                 size_t count, loff_t *ppos)
2223 {
2224         char *data;
2225         struct smack_known *skp;
2226         int rc = count;
2227
2228         if (!smack_privileged(CAP_MAC_ADMIN))
2229                 return -EPERM;
2230
2231         data = kzalloc(count, GFP_KERNEL);
2232         if (data == NULL)
2233                 return -ENOMEM;
2234
2235         if (copy_from_user(data, buf, count) != 0)
2236                 rc = -EFAULT;
2237         else {
2238                 skp = smk_import_entry(data, count);
2239                 if (skp == NULL)
2240                         rc = -EINVAL;
2241                 else
2242                         smack_syslog_label = smk_import_entry(data, count);
2243         }
2244
2245         kfree(data);
2246         return rc;
2247 }
2248
2249 static const struct file_operations smk_syslog_ops = {
2250         .read           = smk_read_syslog,
2251         .write          = smk_write_syslog,
2252         .llseek         = default_llseek,
2253 };
2254
2255
2256 /**
2257  * smk_read_ptrace - read() for /smack/ptrace
2258  * @filp: file pointer, not actually used
2259  * @buf: where to put the result
2260  * @count: maximum to send along
2261  * @ppos: where to start
2262  *
2263  * Returns number of bytes read or error code, as appropriate
2264  */
2265 static ssize_t smk_read_ptrace(struct file *filp, char __user *buf,
2266                                size_t count, loff_t *ppos)
2267 {
2268         char temp[32];
2269         ssize_t rc;
2270
2271         if (*ppos != 0)
2272                 return 0;
2273
2274         sprintf(temp, "%d\n", smack_ptrace_rule);
2275         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
2276         return rc;
2277 }
2278
2279 /**
2280  * smk_write_ptrace - write() for /smack/ptrace
2281  * @file: file pointer
2282  * @buf: data from user space
2283  * @count: bytes sent
2284  * @ppos: where to start - must be 0
2285  */
2286 static ssize_t smk_write_ptrace(struct file *file, const char __user *buf,
2287                                 size_t count, loff_t *ppos)
2288 {
2289         char temp[32];
2290         int i;
2291
2292         if (!smack_privileged(CAP_MAC_ADMIN))
2293                 return -EPERM;
2294
2295         if (*ppos != 0 || count >= sizeof(temp) || count == 0)
2296                 return -EINVAL;
2297
2298         if (copy_from_user(temp, buf, count) != 0)
2299                 return -EFAULT;
2300
2301         temp[count] = '\0';
2302
2303         if (sscanf(temp, "%d", &i) != 1)
2304                 return -EINVAL;
2305         if (i < SMACK_PTRACE_DEFAULT || i > SMACK_PTRACE_MAX)
2306                 return -EINVAL;
2307         smack_ptrace_rule = i;
2308
2309         return count;
2310 }
2311
2312 static const struct file_operations smk_ptrace_ops = {
2313         .write          = smk_write_ptrace,
2314         .read           = smk_read_ptrace,
2315         .llseek         = default_llseek,
2316 };
2317
2318 /**
2319  * smk_fill_super - fill the smackfs superblock
2320  * @sb: the empty superblock
2321  * @data: unused
2322  * @silent: unused
2323  *
2324  * Fill in the well known entries for the smack filesystem
2325  *
2326  * Returns 0 on success, an error code on failure
2327  */
2328 static int smk_fill_super(struct super_block *sb, void *data, int silent)
2329 {
2330         int rc;
2331         struct inode *root_inode;
2332
2333         static struct tree_descr smack_files[] = {
2334                 [SMK_LOAD] = {
2335                         "load", &smk_load_ops, S_IRUGO|S_IWUSR},
2336                 [SMK_CIPSO] = {
2337                         "cipso", &smk_cipso_ops, S_IRUGO|S_IWUSR},
2338                 [SMK_DOI] = {
2339                         "doi", &smk_doi_ops, S_IRUGO|S_IWUSR},
2340                 [SMK_DIRECT] = {
2341                         "direct", &smk_direct_ops, S_IRUGO|S_IWUSR},
2342                 [SMK_AMBIENT] = {
2343                         "ambient", &smk_ambient_ops, S_IRUGO|S_IWUSR},
2344                 [SMK_NETLBLADDR] = {
2345                         "netlabel", &smk_netlbladdr_ops, S_IRUGO|S_IWUSR},
2346                 [SMK_ONLYCAP] = {
2347                         "onlycap", &smk_onlycap_ops, S_IRUGO|S_IWUSR},
2348                 [SMK_LOGGING] = {
2349                         "logging", &smk_logging_ops, S_IRUGO|S_IWUSR},
2350                 [SMK_LOAD_SELF] = {
2351                         "load-self", &smk_load_self_ops, S_IRUGO|S_IWUGO},
2352                 [SMK_ACCESSES] = {
2353                         "access", &smk_access_ops, S_IRUGO|S_IWUGO},
2354                 [SMK_MAPPED] = {
2355                         "mapped", &smk_mapped_ops, S_IRUGO|S_IWUSR},
2356                 [SMK_LOAD2] = {
2357                         "load2", &smk_load2_ops, S_IRUGO|S_IWUSR},
2358                 [SMK_LOAD_SELF2] = {
2359                         "load-self2", &smk_load_self2_ops, S_IRUGO|S_IWUGO},
2360                 [SMK_ACCESS2] = {
2361                         "access2", &smk_access2_ops, S_IRUGO|S_IWUGO},
2362                 [SMK_CIPSO2] = {
2363                         "cipso2", &smk_cipso2_ops, S_IRUGO|S_IWUSR},
2364                 [SMK_REVOKE_SUBJ] = {
2365                         "revoke-subject", &smk_revoke_subj_ops,
2366                         S_IRUGO|S_IWUSR},
2367                 [SMK_CHANGE_RULE] = {
2368                         "change-rule", &smk_change_rule_ops, S_IRUGO|S_IWUSR},
2369                 [SMK_SYSLOG] = {
2370                         "syslog", &smk_syslog_ops, S_IRUGO|S_IWUSR},
2371                 [SMK_PTRACE] = {
2372                         "ptrace", &smk_ptrace_ops, S_IRUGO|S_IWUSR},
2373                 /* last one */
2374                         {""}
2375         };
2376
2377         rc = simple_fill_super(sb, SMACK_MAGIC, smack_files);
2378         if (rc != 0) {
2379                 printk(KERN_ERR "%s failed %d while creating inodes\n",
2380                         __func__, rc);
2381                 return rc;
2382         }
2383
2384         root_inode = sb->s_root->d_inode;
2385
2386         return 0;
2387 }
2388
2389 /**
2390  * smk_mount - get the smackfs superblock
2391  * @fs_type: passed along without comment
2392  * @flags: passed along without comment
2393  * @dev_name: passed along without comment
2394  * @data: passed along without comment
2395  *
2396  * Just passes everything along.
2397  *
2398  * Returns what the lower level code does.
2399  */
2400 static struct dentry *smk_mount(struct file_system_type *fs_type,
2401                       int flags, const char *dev_name, void *data)
2402 {
2403         return mount_single(fs_type, flags, data, smk_fill_super);
2404 }
2405
2406 static struct file_system_type smk_fs_type = {
2407         .name           = "smackfs",
2408         .mount          = smk_mount,
2409         .kill_sb        = kill_litter_super,
2410 };
2411
2412 static struct vfsmount *smackfs_mount;
2413
2414 static int __init smk_preset_netlabel(struct smack_known *skp)
2415 {
2416         skp->smk_netlabel.domain = skp->smk_known;
2417         skp->smk_netlabel.flags =
2418                 NETLBL_SECATTR_DOMAIN | NETLBL_SECATTR_MLS_LVL;
2419         return smk_netlbl_mls(smack_cipso_direct, skp->smk_known,
2420                                 &skp->smk_netlabel, strlen(skp->smk_known));
2421 }
2422
2423 /**
2424  * init_smk_fs - get the smackfs superblock
2425  *
2426  * register the smackfs
2427  *
2428  * Do not register smackfs if Smack wasn't enabled
2429  * on boot. We can not put this method normally under the
2430  * smack_init() code path since the security subsystem get
2431  * initialized before the vfs caches.
2432  *
2433  * Returns true if we were not chosen on boot or if
2434  * we were chosen and filesystem registration succeeded.
2435  */
2436 static int __init init_smk_fs(void)
2437 {
2438         int err;
2439         int rc;
2440
2441         if (!security_module_enable(&smack_ops))
2442                 return 0;
2443
2444         err = smk_init_sysfs();
2445         if (err)
2446                 printk(KERN_ERR "smackfs: sysfs mountpoint problem.\n");
2447
2448         err = register_filesystem(&smk_fs_type);
2449         if (!err) {
2450                 smackfs_mount = kern_mount(&smk_fs_type);
2451                 if (IS_ERR(smackfs_mount)) {
2452                         printk(KERN_ERR "smackfs:  could not mount!\n");
2453                         err = PTR_ERR(smackfs_mount);
2454                         smackfs_mount = NULL;
2455                 }
2456         }
2457
2458         smk_cipso_doi();
2459         smk_unlbl_ambient(NULL);
2460
2461         rc = smk_preset_netlabel(&smack_known_floor);
2462         if (err == 0 && rc < 0)
2463                 err = rc;
2464         rc = smk_preset_netlabel(&smack_known_hat);
2465         if (err == 0 && rc < 0)
2466                 err = rc;
2467         rc = smk_preset_netlabel(&smack_known_huh);
2468         if (err == 0 && rc < 0)
2469                 err = rc;
2470         rc = smk_preset_netlabel(&smack_known_invalid);
2471         if (err == 0 && rc < 0)
2472                 err = rc;
2473         rc = smk_preset_netlabel(&smack_known_star);
2474         if (err == 0 && rc < 0)
2475                 err = rc;
2476         rc = smk_preset_netlabel(&smack_known_web);
2477         if (err == 0 && rc < 0)
2478                 err = rc;
2479
2480         return err;
2481 }
2482
2483 __initcall(init_smk_fs);