← Back to branch summary

~ubuntu-branches/ubuntu/raring/apparmor/raring

« back to all changes in this revision

Viewing changes to kernel-patches/for-mainline/null_module/foobar-lsm.c

  • Committer: Bazaar Package Importer
  • Author(s): Kees Cook
  • Date: 2007-03-23 16:42:01 UTC
  • Revision ID: james.westby@ubuntu.com-20070323164201-jkax6f0oku087b7l
Tags: upstream-2.0.1+510.dfsg
Import upstream version 2.0.1+510.dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
kernel-patches/for-mainline/null_module/foobar-lsm.c
 
1
#include <linux/security.h>
 
2
#include <linux/module.h>
 
3
#include <linux/namei.h>
 
4
 
 
5
static void log_path(char *op, struct dentry *dentry, struct vfsmount *mnt)
 
6
{
 
7
        char *page, *name;
 
8
 
 
9
        if (!mnt) {
 
10
                printk(KERN_INFO "foobar(%s): %p NULL vfsmnt\n", op, dentry);
 
11
                return;
 
12
        }
 
13
                        
 
14
        page = (char *)__get_free_page(GFP_KERNEL);
 
15
        if (!page) {
 
16
                printk(KERN_ERR "foobar(%s): Unable to get page for path %p/%p\n",
 
17
                        op, mnt, dentry);
 
18
                goto out;
 
19
        }
 
20
 
 
21
        name=d_path(dentry, mnt, page, PAGE_SIZE);
 
22
        if (IS_ERR(name)){
 
23
                printk(KERN_ERR "foobar(%s): Error path %p/%p overflowed buffer\n",
 
24
                        op, mnt, dentry);
 
25
                goto out;
 
26
        }
 
27
 
 
28
        printk(KERN_INFO "foobar(%s): %p/%p->'%s'\n",
 
29
                op, mnt, dentry, name);
 
30
 
 
31
out:
 
32
        if (page)
 
33
                free_page((unsigned long)page);
 
34
}
 
35
 
 
36
static int foobar_inode_mkdir(struct inode *inode, struct dentry *dentry,
 
37
                                 struct vfsmount *mnt, int mask)
 
38
{
 
39
        log_path("inode_mkdir", dentry, mnt);
 
40
 
 
41
        return 0;
 
42
}
 
43
 
 
44
static int foobar_inode_rmdir(struct inode *inode, struct dentry *dentry,
 
45
                              struct vfsmount *mnt)
 
46
{
 
47
        log_path("inode_rmdir", dentry, mnt);
 
48
 
 
49
        return 0;
 
50
}
 
51
 
 
52
static int foobar_inode_create(struct inode *inode, struct dentry *dentry,
 
53
                               struct vfsmount *mnt, int mask)
 
54
{
 
55
        log_path("inode_create", dentry, mnt);
 
56
 
 
57
        return 0;
 
58
}
 
59
 
 
60
static int foobar_inode_link(struct dentry *old_dentry, 
 
61
                             struct vfsmount *old_mnt,
 
62
                             struct inode *inode,
 
63
                             struct dentry *new_dentry,
 
64
                             struct vfsmount *new_mnt)
 
65
{
 
66
        log_path("inode_link (old)", old_dentry, old_mnt);
 
67
        log_path("inode_link (new)", new_dentry, new_mnt);
 
68
 
 
69
        return 0;
 
70
}
 
71
 
 
72
static int foobar_inode_unlink(struct inode *dir, struct dentry *dentry,
 
73
                             struct vfsmount *mnt)
 
74
{
 
75
        log_path("inode_unlink", dentry, mnt);
 
76
 
 
77
        return 0;
 
78
}
 
79
 
 
80
static int foobar_inode_mknod(struct inode *inode, struct dentry *dentry,
 
81
                              struct vfsmount *mnt, int mode, dev_t dev)
 
82
{
 
83
        log_path("inode_mknod", dentry, mnt);
 
84
 
 
85
        return 0;
 
86
}
 
87
 
 
88
static int foobar_inode_rename(struct inode *old_inode,
 
89
                               struct dentry *old_dentry, 
 
90
                               struct vfsmount *old_mnt,
 
91
                               struct inode *new_inode,
 
92
                               struct dentry *new_dentry,
 
93
                               struct vfsmount *new_mnt)
 
94
{
 
95
        log_path("inode_rename (old)", old_dentry, old_mnt);
 
96
        log_path("inode_rename (new)", new_dentry, new_mnt);
 
97
 
 
98
        return 0;
 
99
}
 
100
 
 
101
static int foobar_inode_setattr(struct dentry *dentry, struct vfsmount *mnt, 
 
102
                                struct iattr *iattr)
 
103
{
 
104
        log_path("inode_setattr", dentry, mnt);
 
105
 
 
106
        return 0;
 
107
}
 
108
 
 
109
static int foobar_inode_setxattr(struct dentry *dentry, struct vfsmount *mnt, 
 
110
                                 char *name, void *value, size_t size, 
 
111
                                 int flags)
 
112
{
 
113
        log_path("inode_setxattr", dentry, mnt);
 
114
 
 
115
        return 0;
 
116
}
 
117
 
 
118
static int foobar_inode_getxattr(struct dentry *dentry, 
 
119
                                 struct vfsmount *mnt, char *name)
 
120
{
 
121
        log_path("inode_getxattr", dentry, mnt);
 
122
 
 
123
        return 0;
 
124
}
 
125
 
 
126
static int foobar_inode_listxattr(struct dentry *dentry,
 
127
                                  struct vfsmount *mnt)
 
128
{
 
129
        log_path("inode_listxattr", dentry, mnt);
 
130
 
 
131
        return 0;
 
132
}
 
133
 
 
134
static int foobar_inode_removexattr(struct dentry *dentry, 
 
135
                                    struct vfsmount *mnt, char *name)
 
136
{
 
137
        log_path("inode_removexattr", dentry, mnt);
 
138
 
 
139
        return 0;
 
140
}
 
141
 
 
142
static int foobar_inode_symlink(struct inode *dir,
 
143
                                struct dentry *dentry, struct vfsmount *mnt, 
 
144
                                const char *old_name)
 
145
{
 
146
        log_path("inode_symlink", dentry, mnt);
 
147
 
 
148
        return 0;
 
149
}
 
150
 
 
151
static int foobar_inode_permission(struct inode *inode, int mask,
 
152
                                      struct nameidata *nd)
 
153
{
 
154
        log_path("inode_permission", nd->dentry, nd->mnt);
 
155
 
 
156
        return 0;
 
157
}
 
158
 
 
159
struct security_operations foobar_ops = {
 
160
        .inode_create =         foobar_inode_create,
 
161
        .inode_link =           foobar_inode_link,
 
162
        .inode_unlink =         foobar_inode_unlink,
 
163
        .inode_mkdir =          foobar_inode_mkdir,
 
164
        .inode_rmdir =          foobar_inode_rmdir,
 
165
        .inode_mknod =          foobar_inode_mknod,
 
166
        .inode_rename =         foobar_inode_rename,
 
167
        .inode_setattr =        foobar_inode_setattr,
 
168
        .inode_setxattr =       foobar_inode_setxattr,
 
169
        .inode_getxattr =       foobar_inode_getxattr,
 
170
        .inode_listxattr =      foobar_inode_listxattr,
 
171
        .inode_removexattr =    foobar_inode_removexattr,
 
172
        .inode_symlink =        foobar_inode_symlink,
 
173
//      .inode_permission =     foobar_inode_permission,
 
174
};
 
175
 
 
176
static int __init foobar_init(void)
 
177
{
 
178
int error;
 
179
 
 
180
        if ((error = register_security(&foobar_ops))) {
 
181
                printk(KERN_ERR "Unable to load dummy module\n");
 
182
        }
 
183
 
 
184
        return error;
 
185
}
 
186
 
 
187
static void __exit foobar_exit(void)
 
188
{
 
189
        if (unregister_security(&foobar_ops))
 
190
                printk(KERN_ERR "Unable to properly unregister module\n");
 
191
}
 
192
 
 
193
module_init(foobar_init);
 
194
module_exit(foobar_exit);
 
195
 
 
196
MODULE_DESCRIPTION("Test module");
 
197
MODULE_LICENSE("GPL");