TOMOYO: Change pathname for non-rename()able filesystems.
[linux-2.6.git] / security / tomoyo / realpath.c
1 /*
2  * security/tomoyo/realpath.c
3  *
4  * Pathname calculation functions for TOMOYO.
5  *
6  * Copyright (C) 2005-2010  NTT DATA CORPORATION
7  */
8
9 #include <linux/types.h>
10 #include <linux/mount.h>
11 #include <linux/mnt_namespace.h>
12 #include <linux/fs_struct.h>
13 #include <linux/magic.h>
14 #include <linux/slab.h>
15 #include <net/sock.h>
16 #include "common.h"
17 #include "../../fs/internal.h"
18
19 /**
20  * tomoyo_encode: Convert binary string to ascii string.
21  *
22  * @str: String in binary format.
23  *
24  * Returns pointer to @str in ascii format on success, NULL otherwise.
25  *
26  * This function uses kzalloc(), so caller must kfree() if this function
27  * didn't return NULL.
28  */
29 char *tomoyo_encode(const char *str)
30 {
31         int len = 0;
32         const char *p = str;
33         char *cp;
34         char *cp0;
35
36         if (!p)
37                 return NULL;
38         while (*p) {
39                 const unsigned char c = *p++;
40                 if (c == '\\')
41                         len += 2;
42                 else if (c > ' ' && c < 127)
43                         len++;
44                 else
45                         len += 4;
46         }
47         len++;
48         /* Reserve space for appending "/". */
49         cp = kzalloc(len + 10, GFP_NOFS);
50         if (!cp)
51                 return NULL;
52         cp0 = cp;
53         p = str;
54         while (*p) {
55                 const unsigned char c = *p++;
56
57                 if (c == '\\') {
58                         *cp++ = '\\';
59                         *cp++ = '\\';
60                 } else if (c > ' ' && c < 127) {
61                         *cp++ = c;
62                 } else {
63                         *cp++ = '\\';
64                         *cp++ = (c >> 6) + '0';
65                         *cp++ = ((c >> 3) & 7) + '0';
66                         *cp++ = (c & 7) + '0';
67                 }
68         }
69         return cp0;
70 }
71
72 /**
73  * tomoyo_get_absolute_path - Get the path of a dentry but ignores chroot'ed root.
74  *
75  * @path:   Pointer to "struct path".
76  * @buffer: Pointer to buffer to return value in.
77  * @buflen: Sizeof @buffer.
78  *
79  * Returns the buffer on success, an error code otherwise.
80  *
81  * If dentry is a directory, trailing '/' is appended.
82  */
83 static char *tomoyo_get_absolute_path(struct path *path, char * const buffer,
84                                       const int buflen)
85 {
86         char *pos = ERR_PTR(-ENOMEM);
87         if (buflen >= 256) {
88                 struct path ns_root = { };
89                 /* go to whatever namespace root we are under */
90                 pos = __d_path(path, &ns_root, buffer, buflen - 1);
91                 if (!IS_ERR(pos) && *pos == '/' && pos[1]) {
92                         struct inode *inode = path->dentry->d_inode;
93                         if (inode && S_ISDIR(inode->i_mode)) {
94                                 buffer[buflen - 2] = '/';
95                                 buffer[buflen - 1] = '\0';
96                         }
97                 }
98         }
99         return pos;
100 }
101
102 /**
103  * tomoyo_get_dentry_path - Get the path of a dentry.
104  *
105  * @dentry: Pointer to "struct dentry".
106  * @buffer: Pointer to buffer to return value in.
107  * @buflen: Sizeof @buffer.
108  *
109  * Returns the buffer on success, an error code otherwise.
110  *
111  * If dentry is a directory, trailing '/' is appended.
112  */
113 static char *tomoyo_get_dentry_path(struct dentry *dentry, char * const buffer,
114                                     const int buflen)
115 {
116         char *pos = ERR_PTR(-ENOMEM);
117         if (buflen >= 256) {
118                 pos = dentry_path_raw(dentry, buffer, buflen - 1);
119                 if (!IS_ERR(pos) && *pos == '/' && pos[1]) {
120                         struct inode *inode = dentry->d_inode;
121                         if (inode && S_ISDIR(inode->i_mode)) {
122                                 buffer[buflen - 2] = '/';
123                                 buffer[buflen - 1] = '\0';
124                         }
125                 }
126         }
127         return pos;
128 }
129
130 /**
131  * tomoyo_get_local_path - Get the path of a dentry.
132  *
133  * @dentry: Pointer to "struct dentry".
134  * @buffer: Pointer to buffer to return value in.
135  * @buflen: Sizeof @buffer.
136  *
137  * Returns the buffer on success, an error code otherwise.
138  */
139 static char *tomoyo_get_local_path(struct dentry *dentry, char * const buffer,
140                                    const int buflen)
141 {
142         struct super_block *sb = dentry->d_sb;
143         char *pos = tomoyo_get_dentry_path(dentry, buffer, buflen);
144         if (IS_ERR(pos))
145                 return pos;
146         /* Convert from $PID to self if $PID is current thread. */
147         if (sb->s_magic == PROC_SUPER_MAGIC && *pos == '/') {
148                 char *ep;
149                 const pid_t pid = (pid_t) simple_strtoul(pos + 1, &ep, 10);
150                 if (*ep == '/' && pid && pid ==
151                     task_tgid_nr_ns(current, sb->s_fs_info)) {
152                         pos = ep - 5;
153                         if (pos < buffer)
154                                 goto out;
155                         memmove(pos, "/self", 5);
156                 }
157                 goto prepend_filesystem_name;
158         }
159         /* Use filesystem name for unnamed devices. */
160         if (!MAJOR(sb->s_dev))
161                 goto prepend_filesystem_name;
162         {
163                 struct inode *inode = sb->s_root->d_inode;
164                 /*
165                  * Use filesystem name if filesystem does not support rename()
166                  * operation.
167                  */
168                 if (inode->i_op && !inode->i_op->rename)
169                         goto prepend_filesystem_name;
170         }
171         /* Prepend device name. */
172         {
173                 char name[64];
174                 int name_len;
175                 const dev_t dev = sb->s_dev;
176                 name[sizeof(name) - 1] = '\0';
177                 snprintf(name, sizeof(name) - 1, "dev(%u,%u):", MAJOR(dev),
178                          MINOR(dev));
179                 name_len = strlen(name);
180                 pos -= name_len;
181                 if (pos < buffer)
182                         goto out;
183                 memmove(pos, name, name_len);
184                 return pos;
185         }
186         /* Prepend filesystem name. */
187 prepend_filesystem_name:
188         {
189                 const char *name = sb->s_type->name;
190                 const int name_len = strlen(name);
191                 pos -= name_len + 1;
192                 if (pos < buffer)
193                         goto out;
194                 memmove(pos, name, name_len);
195                 pos[name_len] = ':';
196         }
197         return pos;
198 out:
199         return ERR_PTR(-ENOMEM);
200 }
201
202 /**
203  * tomoyo_get_socket_name - Get the name of a socket.
204  *
205  * @path:   Pointer to "struct path".
206  * @buffer: Pointer to buffer to return value in.
207  * @buflen: Sizeof @buffer.
208  *
209  * Returns the buffer.
210  */
211 static char *tomoyo_get_socket_name(struct path *path, char * const buffer,
212                                     const int buflen)
213 {
214         struct inode *inode = path->dentry->d_inode;
215         struct socket *sock = inode ? SOCKET_I(inode) : NULL;
216         struct sock *sk = sock ? sock->sk : NULL;
217         if (sk) {
218                 snprintf(buffer, buflen, "socket:[family=%u:type=%u:"
219                          "protocol=%u]", sk->sk_family, sk->sk_type,
220                          sk->sk_protocol);
221         } else {
222                 snprintf(buffer, buflen, "socket:[unknown]");
223         }
224         return buffer;
225 }
226
227 /**
228  * tomoyo_realpath_from_path - Returns realpath(3) of the given pathname but ignores chroot'ed root.
229  *
230  * @path: Pointer to "struct path".
231  *
232  * Returns the realpath of the given @path on success, NULL otherwise.
233  *
234  * If dentry is a directory, trailing '/' is appended.
235  * Characters out of 0x20 < c < 0x7F range are converted to
236  * \ooo style octal string.
237  * Character \ is converted to \\ string.
238  *
239  * These functions use kzalloc(), so the caller must call kfree()
240  * if these functions didn't return NULL.
241  */
242 char *tomoyo_realpath_from_path(struct path *path)
243 {
244         char *buf = NULL;
245         char *name = NULL;
246         unsigned int buf_len = PAGE_SIZE / 2;
247         struct dentry *dentry = path->dentry;
248         struct super_block *sb;
249         if (!dentry)
250                 return NULL;
251         sb = dentry->d_sb;
252         while (1) {
253                 char *pos;
254                 struct inode *inode;
255                 buf_len <<= 1;
256                 kfree(buf);
257                 buf = kmalloc(buf_len, GFP_NOFS);
258                 if (!buf)
259                         break;
260                 /* To make sure that pos is '\0' terminated. */
261                 buf[buf_len - 1] = '\0';
262                 /* Get better name for socket. */
263                 if (sb->s_magic == SOCKFS_MAGIC) {
264                         pos = tomoyo_get_socket_name(path, buf, buf_len - 1);
265                         goto encode;
266                 }
267                 /* For "pipe:[\$]". */
268                 if (dentry->d_op && dentry->d_op->d_dname) {
269                         pos = dentry->d_op->d_dname(dentry, buf, buf_len - 1);
270                         goto encode;
271                 }
272                 inode = sb->s_root->d_inode;
273                 /*
274                  * Get local name for filesystems without rename() operation
275                  * or dentry without vfsmount.
276                  */
277                 if (!path->mnt || (inode->i_op && !inode->i_op->rename))
278                         pos = tomoyo_get_local_path(path->dentry, buf,
279                                                     buf_len - 1);
280                 /* Get absolute name for the rest. */
281                 else
282                         pos = tomoyo_get_absolute_path(path, buf, buf_len - 1);
283 encode:
284                 if (IS_ERR(pos))
285                         continue;
286                 name = tomoyo_encode(pos);
287                 break;
288         }
289         kfree(buf);
290         if (!name)
291                 tomoyo_warn_oom(__func__);
292         return name;
293 }
294
295 /**
296  * tomoyo_realpath_nofollow - Get realpath of a pathname.
297  *
298  * @pathname: The pathname to solve.
299  *
300  * Returns the realpath of @pathname on success, NULL otherwise.
301  */
302 char *tomoyo_realpath_nofollow(const char *pathname)
303 {
304         struct path path;
305
306         if (pathname && kern_path(pathname, 0, &path) == 0) {
307                 char *buf = tomoyo_realpath_from_path(&path);
308                 path_put(&path);
309                 return buf;
310         }
311         return NULL;
312 }