This source file includes following definitions.
- permission
- lookup
- follow_link
- dir_namei
- _namei
- lnamei
- namei
- open_namei
- do_mknod
- sys_mknod
- sys_mkdir
- sys_rmdir
- sys_unlink
- sys_symlink
- sys_link
- sys_rename
1
2
3
4
5
6
7
8
9
10
11 #include <asm/segment.h>
12
13 #include <linux/errno.h>
14 #include <linux/sched.h>
15 #include <linux/kernel.h>
16 #include <linux/string.h>
17 #include <linux/fcntl.h>
18 #include <linux/stat.h>
19
20 #define ACC_MODE(x) ("\000\004\002\006"[(x)&O_ACCMODE])
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35 int permission(struct inode * inode,int mask)
36 {
37 int mode = inode->i_mode;
38
39
40 if (inode->i_dev && !inode->i_nlink)
41 return 0;
42 else if (inode->i_op && inode->i_op->permission)
43 return inode->i_op->permission(inode, mask);
44 else if (current->euid == inode->i_uid)
45 mode >>= 6;
46 else if (in_group_p(inode->i_gid))
47 mode >>= 3;
48 if (((mode & mask & 0007) == mask) || suser())
49 return 1;
50 return 0;
51 }
52
53
54
55
56
57
58 int lookup(struct inode * dir,const char * name, int len,
59 struct inode ** result)
60 {
61 struct super_block * sb;
62
63 *result = NULL;
64 if (len==2 && get_fs_byte(name)=='.' && get_fs_byte(name+1)=='.') {
65 if (dir == current->root)
66 len = 1;
67 else if ((sb = dir->i_sb) && (dir == sb->s_mounted)) {
68 sb = dir->i_sb;
69 iput(dir);
70 dir = sb->s_covered;
71 if (dir)
72 dir->i_count++;
73 }
74 }
75 if (!dir)
76 return -ENOENT;
77 if (!dir->i_op || !dir->i_op->lookup) {
78 iput(dir);
79 return -ENOTDIR;
80 }
81 if (!permission(dir,MAY_EXEC)) {
82 iput(dir);
83 return -EACCES;
84 }
85 if (!len) {
86 *result = dir;
87 return 0;
88 }
89 return dir->i_op->lookup(dir,name,len,result);
90 }
91
92 int follow_link(struct inode * dir, struct inode * inode,
93 int flag, int mode, struct inode ** res_inode)
94 {
95 if (!dir || !inode) {
96 iput(dir);
97 iput(inode);
98 *res_inode = NULL;
99 return -ENOENT;
100 }
101 if (!inode->i_op || !inode->i_op->follow_link) {
102 iput(dir);
103 *res_inode = inode;
104 return 0;
105 }
106 return inode->i_op->follow_link(dir,inode,flag,mode,res_inode);
107 }
108
109
110
111
112
113
114
115 static int dir_namei(const char * pathname, int * namelen, const char ** name,
116 struct inode * base, struct inode ** res_inode)
117 {
118 char c;
119 const char * thisname;
120 int len,error;
121 struct inode * inode;
122
123 *res_inode = NULL;
124 if (!base) {
125 base = current->pwd;
126 base->i_count++;
127 }
128 if ((c=get_fs_byte(pathname))=='/') {
129 iput(base);
130 base = current->root;
131 pathname++;
132 base->i_count++;
133 }
134 while (1) {
135 thisname = pathname;
136 for(len=0;(c=get_fs_byte(pathname++))&&(c!='/');len++)
137 ;
138 if (!c)
139 break;
140 base->i_count++;
141 error = lookup(base,thisname,len,&inode);
142 if (error) {
143 iput(base);
144 return error;
145 }
146 error = follow_link(base,inode,0,0,&base);
147 if (error)
148 return error;
149 }
150 if (!base->i_op || !base->i_op->lookup) {
151 iput(base);
152 return -ENOTDIR;
153 }
154 *name = thisname;
155 *namelen = len;
156 *res_inode = base;
157 return 0;
158 }
159
160 static int _namei(const char * pathname, struct inode * base,
161 int follow_links, struct inode ** res_inode)
162 {
163 const char * basename;
164 int namelen,error;
165 struct inode * inode;
166
167 *res_inode = NULL;
168 error = dir_namei(pathname,&namelen,&basename,base,&base);
169 if (error)
170 return error;
171 base->i_count++;
172 error = lookup(base,basename,namelen,&inode);
173 if (error) {
174 iput(base);
175 return error;
176 }
177 if (follow_links) {
178 error = follow_link(base,inode,0,0,&inode);
179 if (error)
180 return error;
181 } else
182 iput(base);
183 *res_inode = inode;
184 return 0;
185 }
186
187 int lnamei(const char * pathname, struct inode ** res_inode)
188 {
189 return _namei(pathname,NULL,0,res_inode);
190 }
191
192
193
194
195
196
197
198
199 int namei(const char * pathname, struct inode ** res_inode)
200 {
201 return _namei(pathname,NULL,1,res_inode);
202 }
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217 int open_namei(const char * pathname, int flag, int mode,
218 struct inode ** res_inode, struct inode * base)
219 {
220 const char * basename;
221 int namelen,error,i;
222 struct inode * dir, *inode;
223 struct task_struct ** p;
224
225 mode &= 07777 & ~current->umask;
226 mode |= S_IFREG;
227 error = dir_namei(pathname,&namelen,&basename,base,&dir);
228 if (error)
229 return error;
230 if (!namelen) {
231 if (flag & 2) {
232 iput(dir);
233 return -EISDIR;
234 }
235
236 if (!permission(dir,ACC_MODE(flag))) {
237 iput(dir);
238 return -EACCES;
239 }
240 *res_inode=dir;
241 return 0;
242 }
243 dir->i_count++;
244 error = lookup(dir,basename,namelen,&inode);
245 if (error) {
246 if (!(flag & O_CREAT)) {
247 iput(dir);
248 return error;
249 }
250 if (!permission(dir,MAY_WRITE)) {
251 iput(dir);
252 return -EACCES;
253 }
254 if (!dir->i_op || !dir->i_op->create) {
255 iput(dir);
256 return -EACCES;
257 }
258 if (IS_RDONLY(dir)) {
259 iput(dir);
260 return -EROFS;
261 }
262 return dir->i_op->create(dir,basename,namelen,mode,res_inode);
263 }
264 if (flag & O_EXCL) {
265 iput(dir);
266 iput(inode);
267 return -EEXIST;
268 }
269 error = follow_link(dir,inode,flag,mode,&inode);
270 if (error)
271 return error;
272 if (S_ISDIR(inode->i_mode) && (flag & 2)) {
273 iput(inode);
274 return -EISDIR;
275 }
276 if (!permission(inode,ACC_MODE(flag))) {
277 iput(inode);
278 return -EACCES;
279 }
280 if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
281 if (IS_NODEV(inode)) {
282 iput(inode);
283 return -EACCES;
284 }
285 } else {
286 if (IS_RDONLY(inode) && (flag & 2)) {
287 iput(inode);
288 return -EROFS;
289 }
290 }
291 if ((inode->i_count > 1) && (flag & 2))
292 for (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
293 if (!*p)
294 continue;
295 if (inode == (*p)->executable) {
296 iput(inode);
297 return -ETXTBSY;
298 }
299 for (i=0; i < (*p)->numlibraries; i++)
300 if (inode == (*p)->libraries[i].library) {
301 iput(inode);
302 return -ETXTBSY;
303 }
304 }
305 *res_inode = inode;
306 return 0;
307 }
308
309 int do_mknod(const char * filename, int mode, dev_t dev)
310 {
311 const char * basename;
312 int namelen, error;
313 struct inode * dir;
314
315 error = dir_namei(filename,&namelen,&basename, NULL, &dir);
316 if (error)
317 return error;
318 if (!namelen) {
319 iput(dir);
320 return -ENOENT;
321 }
322 if (IS_RDONLY(dir)) {
323 iput(dir);
324 return -EROFS;
325 }
326 if (!permission(dir,MAY_WRITE)) {
327 iput(dir);
328 return -EACCES;
329 }
330 if (!dir->i_op || !dir->i_op->mknod) {
331 iput(dir);
332 return -EPERM;
333 }
334 return dir->i_op->mknod(dir,basename,namelen,mode,dev);
335 }
336
337 int sys_mknod(const char * filename, int mode, dev_t dev)
338 {
339 if (S_ISFIFO(mode) || suser())
340 return do_mknod(filename,mode,dev);
341 return -EPERM;
342 }
343
344 int sys_mkdir(const char * pathname, int mode)
345 {
346 const char * basename;
347 int namelen, error;
348 struct inode * dir;
349
350 error = dir_namei(pathname,&namelen,&basename,NULL,&dir);
351 if (error)
352 return error;
353 if (!namelen) {
354 iput(dir);
355 return -ENOENT;
356 }
357 if (IS_RDONLY(dir)) {
358 iput(dir);
359 return -EROFS;
360 }
361 if (!permission(dir,MAY_WRITE)) {
362 iput(dir);
363 return -EACCES;
364 }
365 if (!dir->i_op || !dir->i_op->mkdir) {
366 iput(dir);
367 return -EPERM;
368 }
369 return dir->i_op->mkdir(dir,basename,namelen,mode);
370 }
371
372 int sys_rmdir(const char * name)
373 {
374 const char * basename;
375 int namelen, error;
376 struct inode * dir;
377
378 error = dir_namei(name,&namelen,&basename,NULL,&dir);
379 if (error)
380 return error;
381 if (!namelen) {
382 iput(dir);
383 return -ENOENT;
384 }
385 if (IS_RDONLY(dir)) {
386 iput(dir);
387 return -EROFS;
388 }
389 if (!permission(dir,MAY_WRITE | MAY_EXEC)) {
390 iput(dir);
391 return -EACCES;
392 }
393 if (!dir->i_op || !dir->i_op->rmdir) {
394 iput(dir);
395 return -EPERM;
396 }
397 return dir->i_op->rmdir(dir,basename,namelen);
398 }
399
400 int sys_unlink(const char * name)
401 {
402 const char * basename;
403 int namelen, error;
404 struct inode * dir;
405
406 error = dir_namei(name,&namelen,&basename,NULL,&dir);
407 if (error)
408 return error;
409 if (!namelen) {
410 iput(dir);
411 return -EPERM;
412 }
413 if (IS_RDONLY(dir)) {
414 iput(dir);
415 return -EROFS;
416 }
417 if (!permission(dir,MAY_WRITE | MAY_EXEC)) {
418 iput(dir);
419 return -EACCES;
420 }
421 if (!dir->i_op || !dir->i_op->unlink) {
422 iput(dir);
423 return -EPERM;
424 }
425 return dir->i_op->unlink(dir,basename,namelen);
426 }
427
428 int sys_symlink(const char * oldname, const char * newname)
429 {
430 struct inode * dir;
431 const char * basename;
432 int namelen, error;
433
434 error = dir_namei(newname,&namelen,&basename,NULL,&dir);
435 if (error)
436 return error;
437 if (!namelen) {
438 iput(dir);
439 return -ENOENT;
440 }
441 if (IS_RDONLY(dir)) {
442 iput(dir);
443 return -EROFS;
444 }
445 if (!permission(dir,MAY_WRITE)) {
446 iput(dir);
447 return -EACCES;
448 }
449 if (!dir->i_op || !dir->i_op->symlink) {
450 iput(dir);
451 return -EPERM;
452 }
453 return dir->i_op->symlink(dir,basename,namelen,oldname);
454 }
455
456 int sys_link(const char * oldname, const char * newname)
457 {
458 struct inode * oldinode, * dir;
459 const char * basename;
460 int namelen, error;
461
462 error = namei(oldname, &oldinode);
463 if (error)
464 return error;
465 error = dir_namei(newname,&namelen,&basename,NULL,&dir);
466 if (error) {
467 iput(oldinode);
468 return error;
469 }
470 if (!namelen) {
471 iput(oldinode);
472 iput(dir);
473 return -EPERM;
474 }
475 if (IS_RDONLY(dir)) {
476 iput(oldinode);
477 iput(dir);
478 return -EROFS;
479 }
480 if (dir->i_dev != oldinode->i_dev) {
481 iput(dir);
482 iput(oldinode);
483 return -EXDEV;
484 }
485 if (!permission(dir,MAY_WRITE)) {
486 iput(dir);
487 iput(oldinode);
488 return -EACCES;
489 }
490 if (!dir->i_op || !dir->i_op->link) {
491 iput(dir);
492 iput(oldinode);
493 return -EPERM;
494 }
495 return dir->i_op->link(oldinode, dir, basename, namelen);
496 }
497
498 int sys_rename(const char * oldname, const char * newname)
499 {
500 struct inode * old_dir, * new_dir;
501 const char * old_base, * new_base;
502 int old_len, new_len, error;
503
504 error = dir_namei(oldname,&old_len,&old_base,NULL,&old_dir);
505 if (error)
506 return error;
507 if (!permission(old_dir,MAY_WRITE)) {
508 iput(old_dir);
509 return -EACCES;
510 }
511 if (!old_len || (get_fs_byte(old_base) == '.' &&
512 (old_len == 1 || (get_fs_byte(old_base+1) == '.' &&
513 old_len == 2)))) {
514 iput(old_dir);
515 return -EPERM;
516 }
517 error = dir_namei(newname,&new_len,&new_base,NULL,&new_dir);
518 if (error) {
519 iput(old_dir);
520 return error;
521 }
522 if (!permission(new_dir,MAY_WRITE)) {
523 iput(old_dir);
524 iput(new_dir);
525 return -EACCES;
526 }
527 if (!new_len || (get_fs_byte(new_base) == '.' &&
528 (new_len == 1 || (get_fs_byte(new_base+1) == '.' &&
529 new_len == 2)))) {
530 iput(old_dir);
531 iput(new_dir);
532 return -EPERM;
533 }
534 if (new_dir->i_dev != old_dir->i_dev) {
535 iput(old_dir);
536 iput(new_dir);
537 return -EXDEV;
538 }
539 if (IS_RDONLY(new_dir) || IS_RDONLY(old_dir)) {
540 iput(old_dir);
541 iput(new_dir);
542 return -EROFS;
543 }
544 if (!old_dir->i_op || !old_dir->i_op->rename) {
545 iput(old_dir);
546 iput(new_dir);
547 return -EPERM;
548 }
549 return old_dir->i_op->rename(old_dir, old_base, old_len,
550 new_dir, new_base, new_len);
551 }