AUDIT: Fix compile error in audit_filter_syscall
[linux-2.6.git] / kernel / auditsc.c
1 /* auditsc.c -- System-call auditing support
2  * Handles all system-call specific auditing features.
3  *
4  * Copyright 2003-2004 Red Hat Inc., Durham, North Carolina.
5  * All Rights Reserved.
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  *
21  * Written by Rickard E. (Rik) Faith <faith@redhat.com>
22  *
23  * Many of the ideas implemented here are from Stephen C. Tweedie,
24  * especially the idea of avoiding a copy by using getname.
25  *
26  * The method for actual interception of syscall entry and exit (not in
27  * this file -- see entry.S) is based on a GPL'd patch written by
28  * okir@suse.de and Copyright 2003 SuSE Linux AG.
29  *
30  */
31
32 #include <linux/init.h>
33 #include <asm/atomic.h>
34 #include <asm/types.h>
35 #include <linux/mm.h>
36 #include <linux/module.h>
37 #include <linux/mount.h>
38 #include <linux/socket.h>
39 #include <linux/audit.h>
40 #include <linux/personality.h>
41 #include <linux/time.h>
42 #include <linux/kthread.h>
43 #include <linux/netlink.h>
44 #include <linux/compiler.h>
45 #include <asm/unistd.h>
46
47 /* 0 = no checking
48    1 = put_count checking
49    2 = verbose put_count checking
50 */
51 #define AUDIT_DEBUG 0
52
53 /* No syscall auditing will take place unless audit_enabled != 0. */
54 extern int audit_enabled;
55
56 /* AUDIT_NAMES is the number of slots we reserve in the audit_context
57  * for saving names from getname(). */
58 #define AUDIT_NAMES    20
59
60 /* AUDIT_NAMES_RESERVED is the number of slots we reserve in the
61  * audit_context from being used for nameless inodes from
62  * path_lookup. */
63 #define AUDIT_NAMES_RESERVED 7
64
65 /* At task start time, the audit_state is set in the audit_context using
66    a per-task filter.  At syscall entry, the audit_state is augmented by
67    the syscall filter. */
68 enum audit_state {
69         AUDIT_DISABLED,         /* Do not create per-task audit_context.
70                                  * No syscall-specific audit records can
71                                  * be generated. */
72         AUDIT_SETUP_CONTEXT,    /* Create the per-task audit_context,
73                                  * but don't necessarily fill it in at
74                                  * syscall entry time (i.e., filter
75                                  * instead). */
76         AUDIT_BUILD_CONTEXT,    /* Create the per-task audit_context,
77                                  * and always fill it in at syscall
78                                  * entry time.  This makes a full
79                                  * syscall record available if some
80                                  * other part of the kernel decides it
81                                  * should be recorded. */
82         AUDIT_RECORD_CONTEXT    /* Create the per-task audit_context,
83                                  * always fill it in at syscall entry
84                                  * time, and always write out the audit
85                                  * record at syscall exit time.  */
86 };
87
88 /* When fs/namei.c:getname() is called, we store the pointer in name and
89  * we don't let putname() free it (instead we free all of the saved
90  * pointers at syscall exit time).
91  *
92  * Further, in fs/namei.c:path_lookup() we store the inode and device. */
93 struct audit_names {
94         const char      *name;
95         unsigned long   ino;
96         dev_t           dev;
97         umode_t         mode;
98         uid_t           uid;
99         gid_t           gid;
100         dev_t           rdev;
101         unsigned        flags;
102 };
103
104 struct audit_aux_data {
105         struct audit_aux_data   *next;
106         int                     type;
107 };
108
109 #define AUDIT_AUX_IPCPERM       0
110
111 struct audit_aux_data_ipcctl {
112         struct audit_aux_data   d;
113         struct ipc_perm         p;
114         unsigned long           qbytes;
115         uid_t                   uid;
116         gid_t                   gid;
117         mode_t                  mode;
118 };
119
120 struct audit_aux_data_socketcall {
121         struct audit_aux_data   d;
122         int                     nargs;
123         unsigned long           args[0];
124 };
125
126 struct audit_aux_data_sockaddr {
127         struct audit_aux_data   d;
128         int                     len;
129         char                    a[0];
130 };
131
132 struct audit_aux_data_path {
133         struct audit_aux_data   d;
134         struct dentry           *dentry;
135         struct vfsmount         *mnt;
136 };
137
138 /* The per-task audit context. */
139 struct audit_context {
140         int                 in_syscall; /* 1 if task is in a syscall */
141         enum audit_state    state;
142         unsigned int        serial;     /* serial number for record */
143         struct timespec     ctime;      /* time of syscall entry */
144         uid_t               loginuid;   /* login uid (identity) */
145         int                 major;      /* syscall number */
146         unsigned long       argv[4];    /* syscall arguments */
147         int                 return_valid; /* return code is valid */
148         long                return_code;/* syscall return code */
149         int                 auditable;  /* 1 if record should be written */
150         int                 name_count;
151         struct audit_names  names[AUDIT_NAMES];
152         struct dentry *     pwd;
153         struct vfsmount *   pwdmnt;
154         struct audit_context *previous; /* For nested syscalls */
155         struct audit_aux_data *aux;
156
157                                 /* Save things to print about task_struct */
158         pid_t               pid;
159         uid_t               uid, euid, suid, fsuid;
160         gid_t               gid, egid, sgid, fsgid;
161         unsigned long       personality;
162         int                 arch;
163
164 #if AUDIT_DEBUG
165         int                 put_count;
166         int                 ino_count;
167 #endif
168 };
169
170                                 /* Public API */
171 /* There are three lists of rules -- one to search at task creation
172  * time, one to search at syscall entry time, and another to search at
173  * syscall exit time. */
174 static struct list_head audit_filter_list[AUDIT_NR_FILTERS] = {
175         LIST_HEAD_INIT(audit_filter_list[0]),
176         LIST_HEAD_INIT(audit_filter_list[1]),
177         LIST_HEAD_INIT(audit_filter_list[2]),
178         LIST_HEAD_INIT(audit_filter_list[3]),
179         LIST_HEAD_INIT(audit_filter_list[4]),
180 #if AUDIT_NR_FILTERS != 5
181 #error Fix audit_filter_list initialiser
182 #endif
183 };
184
185 struct audit_entry {
186         struct list_head  list;
187         struct rcu_head   rcu;
188         struct audit_rule rule;
189 };
190
191 extern int audit_pid;
192
193 /* Check to see if two rules are identical.  It is called from
194  * audit_del_rule during AUDIT_DEL. */
195 static int audit_compare_rule(struct audit_rule *a, struct audit_rule *b)
196 {
197         int i;
198
199         if (a->flags != b->flags)
200                 return 1;
201
202         if (a->action != b->action)
203                 return 1;
204
205         if (a->field_count != b->field_count)
206                 return 1;
207
208         for (i = 0; i < a->field_count; i++) {
209                 if (a->fields[i] != b->fields[i]
210                     || a->values[i] != b->values[i])
211                         return 1;
212         }
213
214         for (i = 0; i < AUDIT_BITMASK_SIZE; i++)
215                 if (a->mask[i] != b->mask[i])
216                         return 1;
217
218         return 0;
219 }
220
221 /* Note that audit_add_rule and audit_del_rule are called via
222  * audit_receive() in audit.c, and are protected by
223  * audit_netlink_sem. */
224 static inline void audit_add_rule(struct audit_entry *entry,
225                                   struct list_head *list)
226 {
227         if (entry->rule.flags & AUDIT_FILTER_PREPEND) {
228                 entry->rule.flags &= ~AUDIT_FILTER_PREPEND;
229                 list_add_rcu(&entry->list, list);
230         } else {
231                 list_add_tail_rcu(&entry->list, list);
232         }
233 }
234
235 static void audit_free_rule(struct rcu_head *head)
236 {
237         struct audit_entry *e = container_of(head, struct audit_entry, rcu);
238         kfree(e);
239 }
240
241 /* Note that audit_add_rule and audit_del_rule are called via
242  * audit_receive() in audit.c, and are protected by
243  * audit_netlink_sem. */
244 static inline int audit_del_rule(struct audit_rule *rule,
245                                  struct list_head *list)
246 {
247         struct audit_entry  *e;
248
249         /* Do not use the _rcu iterator here, since this is the only
250          * deletion routine. */
251         list_for_each_entry(e, list, list) {
252                 if (!audit_compare_rule(rule, &e->rule)) {
253                         list_del_rcu(&e->list);
254                         call_rcu(&e->rcu, audit_free_rule);
255                         return 0;
256                 }
257         }
258         return -ENOENT;         /* No matching rule */
259 }
260
261 /* Copy rule from user-space to kernel-space.  Called during
262  * AUDIT_ADD. */
263 static int audit_copy_rule(struct audit_rule *d, struct audit_rule *s)
264 {
265         int i;
266
267         if (s->action != AUDIT_NEVER
268             && s->action != AUDIT_POSSIBLE
269             && s->action != AUDIT_ALWAYS)
270                 return -1;
271         if (s->field_count < 0 || s->field_count > AUDIT_MAX_FIELDS)
272                 return -1;
273         if ((s->flags & ~AUDIT_FILTER_PREPEND) >= AUDIT_NR_FILTERS)
274                 return -1;
275
276         d->flags        = s->flags;
277         d->action       = s->action;
278         d->field_count  = s->field_count;
279         for (i = 0; i < d->field_count; i++) {
280                 d->fields[i] = s->fields[i];
281                 d->values[i] = s->values[i];
282         }
283         for (i = 0; i < AUDIT_BITMASK_SIZE; i++) d->mask[i] = s->mask[i];
284         return 0;
285 }
286
287 static int audit_list_rules(void *_dest)
288 {
289         int pid, seq;
290         int *dest = _dest;
291         struct audit_entry *entry;
292         int i;
293
294         pid = dest[0];
295         seq = dest[1];
296         kfree(dest);
297
298         down(&audit_netlink_sem);
299
300         /* The *_rcu iterators not needed here because we are
301            always called with audit_netlink_sem held. */
302         for (i=0; i<AUDIT_NR_FILTERS; i++) {
303                 list_for_each_entry(entry, &audit_filter_list[i], list)
304                         audit_send_reply(pid, seq, AUDIT_LIST, 0, 1,
305                                          &entry->rule, sizeof(entry->rule));
306         }
307         audit_send_reply(pid, seq, AUDIT_LIST, 1, 1, NULL, 0);
308         
309         up(&audit_netlink_sem);
310         return 0;
311 }
312
313 int audit_receive_filter(int type, int pid, int uid, int seq, void *data,
314                                                         uid_t loginuid)
315 {
316         struct audit_entry *entry;
317         struct task_struct *tsk;
318         int *dest;
319         int                err = 0;
320         unsigned listnr;
321
322         switch (type) {
323         case AUDIT_LIST:
324                 /* We can't just spew out the rules here because we might fill
325                  * the available socket buffer space and deadlock waiting for
326                  * auditctl to read from it... which isn't ever going to
327                  * happen if we're actually running in the context of auditctl
328                  * trying to _send_ the stuff */
329                  
330                 dest = kmalloc(2 * sizeof(int), GFP_KERNEL);
331                 if (!dest)
332                         return -ENOMEM;
333                 dest[0] = pid;
334                 dest[1] = seq;
335
336                 tsk = kthread_run(audit_list_rules, dest, "audit_list_rules");
337                 if (IS_ERR(tsk)) {
338                         kfree(dest);
339                         err = PTR_ERR(tsk);
340                 }
341                 break;
342         case AUDIT_ADD:
343                 if (!(entry = kmalloc(sizeof(*entry), GFP_KERNEL)))
344                         return -ENOMEM;
345                 if (audit_copy_rule(&entry->rule, data)) {
346                         kfree(entry);
347                         return -EINVAL;
348                 }
349                 listnr = entry->rule.flags & ~AUDIT_FILTER_PREPEND;
350                 audit_add_rule(entry, &audit_filter_list[listnr]);
351                 audit_log(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE, 
352                                 "auid=%u added an audit rule\n", loginuid);
353                 break;
354         case AUDIT_DEL:
355                 listnr =((struct audit_rule *)data)->flags & ~AUDIT_FILTER_PREPEND;
356                 if (listnr >= AUDIT_NR_FILTERS)
357                         return -EINVAL;
358
359                 err = audit_del_rule(data, &audit_filter_list[listnr]);
360                 if (!err)
361                         audit_log(NULL, GFP_KERNEL, AUDIT_CONFIG_CHANGE,
362                                   "auid=%u removed an audit rule\n", loginuid);
363                 break;
364         default:
365                 return -EINVAL;
366         }
367
368         return err;
369 }
370
371 /* Compare a task_struct with an audit_rule.  Return 1 on match, 0
372  * otherwise. */
373 static int audit_filter_rules(struct task_struct *tsk,
374                               struct audit_rule *rule,
375                               struct audit_context *ctx,
376                               enum audit_state *state)
377 {
378         int i, j;
379
380         for (i = 0; i < rule->field_count; i++) {
381                 u32 field  = rule->fields[i] & ~AUDIT_NEGATE;
382                 u32 value  = rule->values[i];
383                 int result = 0;
384
385                 switch (field) {
386                 case AUDIT_PID:
387                         result = (tsk->pid == value);
388                         break;
389                 case AUDIT_UID:
390                         result = (tsk->uid == value);
391                         break;
392                 case AUDIT_EUID:
393                         result = (tsk->euid == value);
394                         break;
395                 case AUDIT_SUID:
396                         result = (tsk->suid == value);
397                         break;
398                 case AUDIT_FSUID:
399                         result = (tsk->fsuid == value);
400                         break;
401                 case AUDIT_GID:
402                         result = (tsk->gid == value);
403                         break;
404                 case AUDIT_EGID:
405                         result = (tsk->egid == value);
406                         break;
407                 case AUDIT_SGID:
408                         result = (tsk->sgid == value);
409                         break;
410                 case AUDIT_FSGID:
411                         result = (tsk->fsgid == value);
412                         break;
413                 case AUDIT_PERS:
414                         result = (tsk->personality == value);
415                         break;
416                 case AUDIT_ARCH:
417                         if (ctx) 
418                                 result = (ctx->arch == value);
419                         break;
420
421                 case AUDIT_EXIT:
422                         if (ctx && ctx->return_valid)
423                                 result = (ctx->return_code == value);
424                         break;
425                 case AUDIT_SUCCESS:
426                         if (ctx && ctx->return_valid)
427                                 result = (ctx->return_valid == AUDITSC_SUCCESS);
428                         break;
429                 case AUDIT_DEVMAJOR:
430                         if (ctx) {
431                                 for (j = 0; j < ctx->name_count; j++) {
432                                         if (MAJOR(ctx->names[j].dev)==value) {
433                                                 ++result;
434                                                 break;
435                                         }
436                                 }
437                         }
438                         break;
439                 case AUDIT_DEVMINOR:
440                         if (ctx) {
441                                 for (j = 0; j < ctx->name_count; j++) {
442                                         if (MINOR(ctx->names[j].dev)==value) {
443                                                 ++result;
444                                                 break;
445                                         }
446                                 }
447                         }
448                         break;
449                 case AUDIT_INODE:
450                         if (ctx) {
451                                 for (j = 0; j < ctx->name_count; j++) {
452                                         if (ctx->names[j].ino == value) {
453                                                 ++result;
454                                                 break;
455                                         }
456                                 }
457                         }
458                         break;
459                 case AUDIT_LOGINUID:
460                         result = 0;
461                         if (ctx)
462                                 result = (ctx->loginuid == value);
463                         break;
464                 case AUDIT_ARG0:
465                 case AUDIT_ARG1:
466                 case AUDIT_ARG2:
467                 case AUDIT_ARG3:
468                         if (ctx)
469                                 result = (ctx->argv[field-AUDIT_ARG0]==value);
470                         break;
471                 }
472
473                 if (rule->fields[i] & AUDIT_NEGATE)
474                         result = !result;
475                 if (!result)
476                         return 0;
477         }
478         switch (rule->action) {
479         case AUDIT_NEVER:    *state = AUDIT_DISABLED;       break;
480         case AUDIT_POSSIBLE: *state = AUDIT_BUILD_CONTEXT;  break;
481         case AUDIT_ALWAYS:   *state = AUDIT_RECORD_CONTEXT; break;
482         }
483         return 1;
484 }
485
486 /* At process creation time, we can determine if system-call auditing is
487  * completely disabled for this task.  Since we only have the task
488  * structure at this point, we can only check uid and gid.
489  */
490 static enum audit_state audit_filter_task(struct task_struct *tsk)
491 {
492         struct audit_entry *e;
493         enum audit_state   state;
494
495         rcu_read_lock();
496         list_for_each_entry_rcu(e, &audit_filter_list[AUDIT_FILTER_TASK], list) {
497                 if (audit_filter_rules(tsk, &e->rule, NULL, &state)) {
498                         rcu_read_unlock();
499                         return state;
500                 }
501         }
502         rcu_read_unlock();
503         return AUDIT_BUILD_CONTEXT;
504 }
505
506 /* At syscall entry and exit time, this filter is called if the
507  * audit_state is not low enough that auditing cannot take place, but is
508  * also not high enough that we already know we have to write an audit
509  * record (i.e., the state is AUDIT_SETUP_CONTEXT or  AUDIT_BUILD_CONTEXT).
510  */
511 static enum audit_state audit_filter_syscall(struct task_struct *tsk,
512                                              struct audit_context *ctx,
513                                              struct list_head *list)
514 {
515         struct audit_entry *e;
516         enum audit_state   state;
517         int                word = AUDIT_WORD(ctx->major);
518         int                bit  = AUDIT_BIT(ctx->major);
519
520         if (audit_pid && tsk->tgid == audit_pid)
521                 return AUDIT_DISABLED;
522
523         rcu_read_lock();
524         list_for_each_entry_rcu(e, list, list) {
525                 if ((e->rule.mask[word] & bit) == bit
526                     && audit_filter_rules(tsk, &e->rule, ctx, &state)) {
527                         rcu_read_unlock();
528                         return state;
529                 }
530         }
531         rcu_read_unlock();
532         return AUDIT_BUILD_CONTEXT;
533 }
534
535 static int audit_filter_user_rules(struct netlink_skb_parms *cb,
536                               struct audit_rule *rule,
537                               enum audit_state *state)
538 {
539         int i;
540
541         for (i = 0; i < rule->field_count; i++) {
542                 u32 field  = rule->fields[i] & ~AUDIT_NEGATE;
543                 u32 value  = rule->values[i];
544                 int result = 0;
545
546                 switch (field) {
547                 case AUDIT_PID:
548                         result = (cb->creds.pid == value);
549                         break;
550                 case AUDIT_UID:
551                         result = (cb->creds.uid == value);
552                         break;
553                 case AUDIT_GID:
554                         result = (cb->creds.gid == value);
555                         break;
556                 case AUDIT_LOGINUID:
557                         result = (cb->loginuid == value);
558                         break;
559                 }
560
561                 if (rule->fields[i] & AUDIT_NEGATE)
562                         result = !result;
563                 if (!result)
564                         return 0;
565         }
566         switch (rule->action) {
567         case AUDIT_NEVER:    *state = AUDIT_DISABLED;       break;
568         case AUDIT_POSSIBLE: *state = AUDIT_BUILD_CONTEXT;  break;
569         case AUDIT_ALWAYS:   *state = AUDIT_RECORD_CONTEXT; break;
570         }
571         return 1;
572 }
573
574 int audit_filter_user(struct netlink_skb_parms *cb, int type)
575 {
576         struct audit_entry *e;
577         enum audit_state   state;
578         int ret = 1;
579
580         rcu_read_lock();
581         list_for_each_entry_rcu(e, &audit_filter_list[AUDIT_FILTER_USER], list) {
582                 if (audit_filter_user_rules(cb, &e->rule, &state)) {
583                         if (state == AUDIT_DISABLED)
584                                 ret = 0;
585                         break;
586                 }
587         }
588         rcu_read_unlock();
589
590         return ret; /* Audit by default */
591 }
592
593 /* This should be called with task_lock() held. */
594 static inline struct audit_context *audit_get_context(struct task_struct *tsk,
595                                                       int return_valid,
596                                                       int return_code)
597 {
598         struct audit_context *context = tsk->audit_context;
599
600         if (likely(!context))
601                 return NULL;
602         context->return_valid = return_valid;
603         context->return_code  = return_code;
604
605         if (context->in_syscall && !context->auditable) {
606                 enum audit_state state;
607                 state = audit_filter_syscall(tsk, context, &audit_filter_list[AUDIT_FILTER_EXIT]);
608                 if (state == AUDIT_RECORD_CONTEXT)
609                         context->auditable = 1;
610         }
611
612         context->pid = tsk->pid;
613         context->uid = tsk->uid;
614         context->gid = tsk->gid;
615         context->euid = tsk->euid;
616         context->suid = tsk->suid;
617         context->fsuid = tsk->fsuid;
618         context->egid = tsk->egid;
619         context->sgid = tsk->sgid;
620         context->fsgid = tsk->fsgid;
621         context->personality = tsk->personality;
622         tsk->audit_context = NULL;
623         return context;
624 }
625
626 static inline void audit_free_names(struct audit_context *context)
627 {
628         int i;
629
630 #if AUDIT_DEBUG == 2
631         if (context->auditable
632             ||context->put_count + context->ino_count != context->name_count) {
633                 printk(KERN_ERR "audit.c:%d(:%d): major=%d in_syscall=%d"
634                        " name_count=%d put_count=%d"
635                        " ino_count=%d [NOT freeing]\n",
636                        __LINE__,
637                        context->serial, context->major, context->in_syscall,
638                        context->name_count, context->put_count,
639                        context->ino_count);
640                 for (i = 0; i < context->name_count; i++)
641                         printk(KERN_ERR "names[%d] = %p = %s\n", i,
642                                context->names[i].name,
643                                context->names[i].name);
644                 dump_stack();
645                 return;
646         }
647 #endif
648 #if AUDIT_DEBUG
649         context->put_count  = 0;
650         context->ino_count  = 0;
651 #endif
652
653         for (i = 0; i < context->name_count; i++)
654                 if (context->names[i].name)
655                         __putname(context->names[i].name);
656         context->name_count = 0;
657         if (context->pwd)
658                 dput(context->pwd);
659         if (context->pwdmnt)
660                 mntput(context->pwdmnt);
661         context->pwd = NULL;
662         context->pwdmnt = NULL;
663 }
664
665 static inline void audit_free_aux(struct audit_context *context)
666 {
667         struct audit_aux_data *aux;
668
669         while ((aux = context->aux)) {
670                 if (aux->type == AUDIT_AVC_PATH) {
671                         struct audit_aux_data_path *axi = (void *)aux;
672                         dput(axi->dentry);
673                         mntput(axi->mnt);
674                 }
675                 context->aux = aux->next;
676                 kfree(aux);
677         }
678 }
679
680 static inline void audit_zero_context(struct audit_context *context,
681                                       enum audit_state state)
682 {
683         uid_t loginuid = context->loginuid;
684
685         memset(context, 0, sizeof(*context));
686         context->state      = state;
687         context->loginuid   = loginuid;
688 }
689
690 static inline struct audit_context *audit_alloc_context(enum audit_state state)
691 {
692         struct audit_context *context;
693
694         if (!(context = kmalloc(sizeof(*context), GFP_KERNEL)))
695                 return NULL;
696         audit_zero_context(context, state);
697         return context;
698 }
699
700 /* Filter on the task information and allocate a per-task audit context
701  * if necessary.  Doing so turns on system call auditing for the
702  * specified task.  This is called from copy_process, so no lock is
703  * needed. */
704 int audit_alloc(struct task_struct *tsk)
705 {
706         struct audit_context *context;
707         enum audit_state     state;
708
709         if (likely(!audit_enabled))
710                 return 0; /* Return if not auditing. */
711
712         state = audit_filter_task(tsk);
713         if (likely(state == AUDIT_DISABLED))
714                 return 0;
715
716         if (!(context = audit_alloc_context(state))) {
717                 audit_log_lost("out of memory in audit_alloc");
718                 return -ENOMEM;
719         }
720
721                                 /* Preserve login uid */
722         context->loginuid = -1;
723         if (current->audit_context)
724                 context->loginuid = current->audit_context->loginuid;
725
726         tsk->audit_context  = context;
727         set_tsk_thread_flag(tsk, TIF_SYSCALL_AUDIT);
728         return 0;
729 }
730
731 static inline void audit_free_context(struct audit_context *context)
732 {
733         struct audit_context *previous;
734         int                  count = 0;
735
736         do {
737                 previous = context->previous;
738                 if (previous || (count &&  count < 10)) {
739                         ++count;
740                         printk(KERN_ERR "audit(:%d): major=%d name_count=%d:"
741                                " freeing multiple contexts (%d)\n",
742                                context->serial, context->major,
743                                context->name_count, count);
744                 }
745                 audit_free_names(context);
746                 audit_free_aux(context);
747                 kfree(context);
748                 context  = previous;
749         } while (context);
750         if (count >= 10)
751                 printk(KERN_ERR "audit: freed %d contexts\n", count);
752 }
753
754 static void audit_log_task_info(struct audit_buffer *ab)
755 {
756         char name[sizeof(current->comm)];
757         struct mm_struct *mm = current->mm;
758         struct vm_area_struct *vma;
759
760         get_task_comm(name, current);
761         audit_log_format(ab, " comm=");
762         audit_log_untrustedstring(ab, name);
763
764         if (!mm)
765                 return;
766
767         down_read(&mm->mmap_sem);
768         vma = mm->mmap;
769         while (vma) {
770                 if ((vma->vm_flags & VM_EXECUTABLE) &&
771                     vma->vm_file) {
772                         audit_log_d_path(ab, "exe=",
773                                          vma->vm_file->f_dentry,
774                                          vma->vm_file->f_vfsmnt);
775                         break;
776                 }
777                 vma = vma->vm_next;
778         }
779         up_read(&mm->mmap_sem);
780 }
781
782 static void audit_log_exit(struct audit_context *context, unsigned int gfp_mask)
783 {
784         int i;
785         struct audit_buffer *ab;
786         struct audit_aux_data *aux;
787
788         ab = audit_log_start(context, gfp_mask, AUDIT_SYSCALL);
789         if (!ab)
790                 return;         /* audit_panic has been called */
791         audit_log_format(ab, "arch=%x syscall=%d",
792                          context->arch, context->major);
793         if (context->personality != PER_LINUX)
794                 audit_log_format(ab, " per=%lx", context->personality);
795         if (context->return_valid)
796                 audit_log_format(ab, " success=%s exit=%ld", 
797                                  (context->return_valid==AUDITSC_SUCCESS)?"yes":"no",
798                                  context->return_code);
799         audit_log_format(ab,
800                   " a0=%lx a1=%lx a2=%lx a3=%lx items=%d"
801                   " pid=%d auid=%u uid=%u gid=%u"
802                   " euid=%u suid=%u fsuid=%u"
803                   " egid=%u sgid=%u fsgid=%u",
804                   context->argv[0],
805                   context->argv[1],
806                   context->argv[2],
807                   context->argv[3],
808                   context->name_count,
809                   context->pid,
810                   context->loginuid,
811                   context->uid,
812                   context->gid,
813                   context->euid, context->suid, context->fsuid,
814                   context->egid, context->sgid, context->fsgid);
815         audit_log_task_info(ab);
816         audit_log_end(ab);
817
818         for (aux = context->aux; aux; aux = aux->next) {
819
820                 ab = audit_log_start(context, GFP_KERNEL, aux->type);
821                 if (!ab)
822                         continue; /* audit_panic has been called */
823
824                 switch (aux->type) {
825                 case AUDIT_IPC: {
826                         struct audit_aux_data_ipcctl *axi = (void *)aux;
827                         audit_log_format(ab, 
828                                          " qbytes=%lx iuid=%u igid=%u mode=%x",
829                                          axi->qbytes, axi->uid, axi->gid, axi->mode);
830                         break; }
831
832                 case AUDIT_SOCKETCALL: {
833                         int i;
834                         struct audit_aux_data_socketcall *axs = (void *)aux;
835                         audit_log_format(ab, "nargs=%d", axs->nargs);
836                         for (i=0; i<axs->nargs; i++)
837                                 audit_log_format(ab, " a%d=%lx", i, axs->args[i]);
838                         break; }
839
840                 case AUDIT_SOCKADDR: {
841                         struct audit_aux_data_sockaddr *axs = (void *)aux;
842
843                         audit_log_format(ab, "saddr=");
844                         audit_log_hex(ab, axs->a, axs->len);
845                         break; }
846
847                 case AUDIT_AVC_PATH: {
848                         struct audit_aux_data_path *axi = (void *)aux;
849                         audit_log_d_path(ab, "path=", axi->dentry, axi->mnt);
850                         break; }
851
852                 }
853                 audit_log_end(ab);
854         }
855
856         if (context->pwd && context->pwdmnt) {
857                 ab = audit_log_start(context, GFP_KERNEL, AUDIT_CWD);
858                 if (ab) {
859                         audit_log_d_path(ab, "cwd=", context->pwd, context->pwdmnt);
860                         audit_log_end(ab);
861                 }
862         }
863         for (i = 0; i < context->name_count; i++) {
864                 ab = audit_log_start(context, GFP_KERNEL, AUDIT_PATH);
865                 if (!ab)
866                         continue; /* audit_panic has been called */
867
868                 audit_log_format(ab, "item=%d", i);
869                 if (context->names[i].name) {
870                         audit_log_format(ab, " name=");
871                         audit_log_untrustedstring(ab, context->names[i].name);
872                 }
873                 audit_log_format(ab, " flags=%x\n", context->names[i].flags);
874                          
875                 if (context->names[i].ino != (unsigned long)-1)
876                         audit_log_format(ab, " inode=%lu dev=%02x:%02x mode=%#o"
877                                              " ouid=%u ogid=%u rdev=%02x:%02x",
878                                          context->names[i].ino,
879                                          MAJOR(context->names[i].dev),
880                                          MINOR(context->names[i].dev),
881                                          context->names[i].mode,
882                                          context->names[i].uid,
883                                          context->names[i].gid,
884                                          MAJOR(context->names[i].rdev),
885                                          MINOR(context->names[i].rdev));
886                 audit_log_end(ab);
887         }
888 }
889
890 /* Free a per-task audit context.  Called from copy_process and
891  * __put_task_struct. */
892 void audit_free(struct task_struct *tsk)
893 {
894         struct audit_context *context;
895
896         task_lock(tsk);
897         context = audit_get_context(tsk, 0, 0);
898         task_unlock(tsk);
899
900         if (likely(!context))
901                 return;
902
903         /* Check for system calls that do not go through the exit
904          * function (e.g., exit_group), then free context block. 
905          * We use GFP_ATOMIC here because we might be doing this 
906          * in the context of the idle thread */
907         if (context->in_syscall && context->auditable)
908                 audit_log_exit(context, GFP_ATOMIC);
909
910         audit_free_context(context);
911 }
912
913 /* Fill in audit context at syscall entry.  This only happens if the
914  * audit context was created when the task was created and the state or
915  * filters demand the audit context be built.  If the state from the
916  * per-task filter or from the per-syscall filter is AUDIT_RECORD_CONTEXT,
917  * then the record will be written at syscall exit time (otherwise, it
918  * will only be written if another part of the kernel requests that it
919  * be written). */
920 void audit_syscall_entry(struct task_struct *tsk, int arch, int major,
921                          unsigned long a1, unsigned long a2,
922                          unsigned long a3, unsigned long a4)
923 {
924         struct audit_context *context = tsk->audit_context;
925         enum audit_state     state;
926
927         BUG_ON(!context);
928
929         /* This happens only on certain architectures that make system
930          * calls in kernel_thread via the entry.S interface, instead of
931          * with direct calls.  (If you are porting to a new
932          * architecture, hitting this condition can indicate that you
933          * got the _exit/_leave calls backward in entry.S.)
934          *
935          * i386     no
936          * x86_64   no
937          * ppc64    yes (see arch/ppc64/kernel/misc.S)
938          *
939          * This also happens with vm86 emulation in a non-nested manner
940          * (entries without exits), so this case must be caught.
941          */
942         if (context->in_syscall) {
943                 struct audit_context *newctx;
944
945 #if defined(__NR_vm86) && defined(__NR_vm86old)
946                 /* vm86 mode should only be entered once */
947                 if (major == __NR_vm86 || major == __NR_vm86old)
948                         return;
949 #endif
950 #if AUDIT_DEBUG
951                 printk(KERN_ERR
952                        "audit(:%d) pid=%d in syscall=%d;"
953                        " entering syscall=%d\n",
954                        context->serial, tsk->pid, context->major, major);
955 #endif
956                 newctx = audit_alloc_context(context->state);
957                 if (newctx) {
958                         newctx->previous   = context;
959                         context            = newctx;
960                         tsk->audit_context = newctx;
961                 } else  {
962                         /* If we can't alloc a new context, the best we
963                          * can do is to leak memory (any pending putname
964                          * will be lost).  The only other alternative is
965                          * to abandon auditing. */
966                         audit_zero_context(context, context->state);
967                 }
968         }
969         BUG_ON(context->in_syscall || context->name_count);
970
971         if (!audit_enabled)
972                 return;
973
974         context->arch       = arch;
975         context->major      = major;
976         context->argv[0]    = a1;
977         context->argv[1]    = a2;
978         context->argv[2]    = a3;
979         context->argv[3]    = a4;
980
981         state = context->state;
982         if (state == AUDIT_SETUP_CONTEXT || state == AUDIT_BUILD_CONTEXT)
983                 state = audit_filter_syscall(tsk, context, &audit_filter_list[AUDIT_FILTER_ENTRY]);
984         if (likely(state == AUDIT_DISABLED))
985                 return;
986
987         context->serial     = audit_serial();
988         context->ctime      = CURRENT_TIME;
989         context->in_syscall = 1;
990         context->auditable  = !!(state == AUDIT_RECORD_CONTEXT);
991 }
992
993 /* Tear down after system call.  If the audit context has been marked as
994  * auditable (either because of the AUDIT_RECORD_CONTEXT state from
995  * filtering, or because some other part of the kernel write an audit
996  * message), then write out the syscall information.  In call cases,
997  * free the names stored from getname(). */
998 void audit_syscall_exit(struct task_struct *tsk, int valid, long return_code)
999 {
1000         struct audit_context *context;
1001
1002         get_task_struct(tsk);
1003         task_lock(tsk);
1004         context = audit_get_context(tsk, valid, return_code);
1005         task_unlock(tsk);
1006
1007         /* Not having a context here is ok, since the parent may have
1008          * called __put_task_struct. */
1009         if (likely(!context))
1010                 return;
1011
1012         if (context->in_syscall && context->auditable)
1013                 audit_log_exit(context, GFP_KERNEL);
1014
1015         context->in_syscall = 0;
1016         context->auditable  = 0;
1017
1018         if (context->previous) {
1019                 struct audit_context *new_context = context->previous;
1020                 context->previous  = NULL;
1021                 audit_free_context(context);
1022                 tsk->audit_context = new_context;
1023         } else {
1024                 audit_free_names(context);
1025                 audit_free_aux(context);
1026                 audit_zero_context(context, context->state);
1027                 tsk->audit_context = context;
1028         }
1029         put_task_struct(tsk);
1030 }
1031
1032 /* Add a name to the list.  Called from fs/namei.c:getname(). */
1033 void audit_getname(const char *name)
1034 {
1035         struct audit_context *context = current->audit_context;
1036
1037         if (!context || IS_ERR(name) || !name)
1038                 return;
1039
1040         if (!context->in_syscall) {
1041 #if AUDIT_DEBUG == 2
1042                 printk(KERN_ERR "%s:%d(:%d): ignoring getname(%p)\n",
1043                        __FILE__, __LINE__, context->serial, name);
1044                 dump_stack();
1045 #endif
1046                 return;
1047         }
1048         BUG_ON(context->name_count >= AUDIT_NAMES);
1049         context->names[context->name_count].name = name;
1050         context->names[context->name_count].ino  = (unsigned long)-1;
1051         ++context->name_count;
1052         if (!context->pwd) {
1053                 read_lock(&current->fs->lock);
1054                 context->pwd = dget(current->fs->pwd);
1055                 context->pwdmnt = mntget(current->fs->pwdmnt);
1056                 read_unlock(&current->fs->lock);
1057         }
1058                 
1059 }
1060
1061 /* Intercept a putname request.  Called from
1062  * include/linux/fs.h:putname().  If we have stored the name from
1063  * getname in the audit context, then we delay the putname until syscall
1064  * exit. */
1065 void audit_putname(const char *name)
1066 {
1067         struct audit_context *context = current->audit_context;
1068
1069         BUG_ON(!context);
1070         if (!context->in_syscall) {
1071 #if AUDIT_DEBUG == 2
1072                 printk(KERN_ERR "%s:%d(:%d): __putname(%p)\n",
1073                        __FILE__, __LINE__, context->serial, name);
1074                 if (context->name_count) {
1075                         int i;
1076                         for (i = 0; i < context->name_count; i++)
1077                                 printk(KERN_ERR "name[%d] = %p = %s\n", i,
1078                                        context->names[i].name,
1079                                        context->names[i].name);
1080                 }
1081 #endif
1082                 __putname(name);
1083         }
1084 #if AUDIT_DEBUG
1085         else {
1086                 ++context->put_count;
1087                 if (context->put_count > context->name_count) {
1088                         printk(KERN_ERR "%s:%d(:%d): major=%d"
1089                                " in_syscall=%d putname(%p) name_count=%d"
1090                                " put_count=%d\n",
1091                                __FILE__, __LINE__,
1092                                context->serial, context->major,
1093                                context->in_syscall, name, context->name_count,
1094                                context->put_count);
1095                         dump_stack();
1096                 }
1097         }
1098 #endif
1099 }
1100
1101 /* Store the inode and device from a lookup.  Called from
1102  * fs/namei.c:path_lookup(). */
1103 void audit_inode(const char *name, const struct inode *inode, unsigned flags)
1104 {
1105         int idx;
1106         struct audit_context *context = current->audit_context;
1107
1108         if (!context->in_syscall)
1109                 return;
1110         if (context->name_count
1111             && context->names[context->name_count-1].name
1112             && context->names[context->name_count-1].name == name)
1113                 idx = context->name_count - 1;
1114         else if (context->name_count > 1
1115                  && context->names[context->name_count-2].name
1116                  && context->names[context->name_count-2].name == name)
1117                 idx = context->name_count - 2;
1118         else {
1119                 /* FIXME: how much do we care about inodes that have no
1120                  * associated name? */
1121                 if (context->name_count >= AUDIT_NAMES - AUDIT_NAMES_RESERVED)
1122                         return;
1123                 idx = context->name_count++;
1124                 context->names[idx].name = NULL;
1125 #if AUDIT_DEBUG
1126                 ++context->ino_count;
1127 #endif
1128         }
1129         context->names[idx].flags = flags;
1130         context->names[idx].ino   = inode->i_ino;
1131         context->names[idx].dev   = inode->i_sb->s_dev;
1132         context->names[idx].mode  = inode->i_mode;
1133         context->names[idx].uid   = inode->i_uid;
1134         context->names[idx].gid   = inode->i_gid;
1135         context->names[idx].rdev  = inode->i_rdev;
1136 }
1137
1138 void auditsc_get_stamp(struct audit_context *ctx,
1139                        struct timespec *t, unsigned int *serial)
1140 {
1141         t->tv_sec  = ctx->ctime.tv_sec;
1142         t->tv_nsec = ctx->ctime.tv_nsec;
1143         *serial    = ctx->serial;
1144         ctx->auditable = 1;
1145 }
1146
1147 int audit_set_loginuid(struct task_struct *task, uid_t loginuid)
1148 {
1149         if (task->audit_context) {
1150                 struct audit_buffer *ab;
1151
1152                 ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_LOGIN);
1153                 if (ab) {
1154                         audit_log_format(ab, "login pid=%d uid=%u "
1155                                 "old auid=%u new auid=%u",
1156                                 task->pid, task->uid, 
1157                                 task->audit_context->loginuid, loginuid);
1158                         audit_log_end(ab);
1159                 }
1160                 task->audit_context->loginuid = loginuid;
1161         }
1162         return 0;
1163 }
1164
1165 uid_t audit_get_loginuid(struct audit_context *ctx)
1166 {
1167         return ctx ? ctx->loginuid : -1;
1168 }
1169
1170 int audit_ipc_perms(unsigned long qbytes, uid_t uid, gid_t gid, mode_t mode)
1171 {
1172         struct audit_aux_data_ipcctl *ax;
1173         struct audit_context *context = current->audit_context;
1174
1175         if (likely(!context))
1176                 return 0;
1177
1178         ax = kmalloc(sizeof(*ax), GFP_KERNEL);
1179         if (!ax)
1180                 return -ENOMEM;
1181
1182         ax->qbytes = qbytes;
1183         ax->uid = uid;
1184         ax->gid = gid;
1185         ax->mode = mode;
1186
1187         ax->d.type = AUDIT_IPC;
1188         ax->d.next = context->aux;
1189         context->aux = (void *)ax;
1190         return 0;
1191 }
1192
1193 int audit_socketcall(int nargs, unsigned long *args)
1194 {
1195         struct audit_aux_data_socketcall *ax;
1196         struct audit_context *context = current->audit_context;
1197
1198         if (likely(!context))
1199                 return 0;
1200
1201         ax = kmalloc(sizeof(*ax) + nargs * sizeof(unsigned long), GFP_KERNEL);
1202         if (!ax)
1203                 return -ENOMEM;
1204
1205         ax->nargs = nargs;
1206         memcpy(ax->args, args, nargs * sizeof(unsigned long));
1207
1208         ax->d.type = AUDIT_SOCKETCALL;
1209         ax->d.next = context->aux;
1210         context->aux = (void *)ax;
1211         return 0;
1212 }
1213
1214 int audit_sockaddr(int len, void *a)
1215 {
1216         struct audit_aux_data_sockaddr *ax;
1217         struct audit_context *context = current->audit_context;
1218
1219         if (likely(!context))
1220                 return 0;
1221
1222         ax = kmalloc(sizeof(*ax) + len, GFP_KERNEL);
1223         if (!ax)
1224                 return -ENOMEM;
1225
1226         ax->len = len;
1227         memcpy(ax->a, a, len);
1228
1229         ax->d.type = AUDIT_SOCKADDR;
1230         ax->d.next = context->aux;
1231         context->aux = (void *)ax;
1232         return 0;
1233 }
1234
1235 int audit_avc_path(struct dentry *dentry, struct vfsmount *mnt)
1236 {
1237         struct audit_aux_data_path *ax;
1238         struct audit_context *context = current->audit_context;
1239
1240         if (likely(!context))
1241                 return 0;
1242
1243         ax = kmalloc(sizeof(*ax), GFP_ATOMIC);
1244         if (!ax)
1245                 return -ENOMEM;
1246
1247         ax->dentry = dget(dentry);
1248         ax->mnt = mntget(mnt);
1249
1250         ax->d.type = AUDIT_AVC_PATH;
1251         ax->d.next = context->aux;
1252         context->aux = (void *)ax;
1253         return 0;
1254 }
1255
1256 void audit_signal_info(int sig, struct task_struct *t)
1257 {
1258         extern pid_t audit_sig_pid;
1259         extern uid_t audit_sig_uid;
1260
1261         if (unlikely(audit_pid && t->tgid == audit_pid)) {
1262                 if (sig == SIGTERM || sig == SIGHUP) {
1263                         struct audit_context *ctx = current->audit_context;
1264                         audit_sig_pid = current->pid;
1265                         if (ctx)
1266                                 audit_sig_uid = ctx->loginuid;
1267                         else
1268                                 audit_sig_uid = current->uid;
1269                 }
1270         }
1271 }
1272