4 * Copyright (C) 1997 Richard Günther
6 * binfmt_misc detects binaries via a magic or filename extension and invokes
7 * a specified wrapper. This should obsolete binfmt_java, binfmt_em86 and
10 * 1997-04-25 first version
13 * 1997-06-26 hpa: pass the real filename rather than argv[0]
14 * 1997-06-30 minor cleanup
15 * 1997-08-09 removed extension stripping, locking cleanup
16 * 2001-02-28 AV: rewritten into something that resembles C. Original didn't.
19 #include <linux/module.h>
20 #include <linux/init.h>
22 #include <linux/binfmts.h>
23 #include <linux/slab.h>
24 #include <linux/ctype.h>
25 #include <linux/file.h>
26 #include <linux/pagemap.h>
27 #include <linux/namei.h>
28 #include <linux/mount.h>
29 #include <linux/syscalls.h>
31 #include <asm/uaccess.h>
34 VERBOSE_STATUS
= 1 /* make it zero to save 400 bytes kernel memory */
37 static LIST_HEAD(entries
);
38 static int enabled
= 1;
40 enum {Enabled
, Magic
};
41 #define MISC_FMT_PRESERVE_ARGV0 (1<<31)
42 #define MISC_FMT_OPEN_BINARY (1<<30)
43 #define MISC_FMT_CREDENTIALS (1<<29)
46 struct list_head list
;
47 unsigned long flags
; /* type, status, etc. */
48 int offset
; /* offset of magic */
49 int size
; /* size of magic/mask */
50 char *magic
; /* magic or filename extension */
51 char *mask
; /* mask, NULL for exact match */
52 char *interpreter
; /* filename of interpreter */
54 struct dentry
*dentry
;
57 static rwlock_t entries_lock
= RW_LOCK_UNLOCKED
;
58 static struct vfsmount
*bm_mnt
;
59 static int entry_count
;
62 * Check if we support the binfmt
63 * if we do, return the node, else NULL
64 * locking is done in load_misc_binary
66 static Node
*check_file(struct linux_binprm
*bprm
)
68 char *p
= strrchr(bprm
->interp
, '.');
71 list_for_each(l
, &entries
) {
72 Node
*e
= list_entry(l
, Node
, list
);
76 if (!test_bit(Enabled
, &e
->flags
))
79 if (!test_bit(Magic
, &e
->flags
)) {
80 if (p
&& !strcmp(e
->magic
, p
+ 1))
85 s
= bprm
->buf
+ e
->offset
;
87 for (j
= 0; j
< e
->size
; j
++)
88 if ((*s
++ ^ e
->magic
[j
]) & e
->mask
[j
])
91 for (j
= 0; j
< e
->size
; j
++)
92 if ((*s
++ ^ e
->magic
[j
]))
104 static int load_misc_binary(struct linux_binprm
*bprm
, struct pt_regs
*regs
)
107 struct file
* interp_file
= NULL
;
108 char iname
[BINPRM_BUF_SIZE
];
109 char *iname_addr
= iname
;
112 struct files_struct
*files
= NULL
;
118 /* to keep locking time low, we copy the interpreter string */
119 read_lock(&entries_lock
);
120 fmt
= check_file(bprm
);
122 strlcpy(iname
, fmt
->interpreter
, BINPRM_BUF_SIZE
);
123 read_unlock(&entries_lock
);
127 if (!(fmt
->flags
& MISC_FMT_PRESERVE_ARGV0
)) {
128 remove_arg_zero(bprm
);
131 if (fmt
->flags
& MISC_FMT_OPEN_BINARY
) {
133 files
= current
->files
;
134 retval
= unshare_files();
137 if (files
== current
->files
) {
138 put_files_struct(files
);
141 /* if the binary should be opened on behalf of the
142 * interpreter than keep it open and assign descriptor
144 fd_binary
= get_unused_fd();
149 fd_install(fd_binary
, bprm
->file
);
151 /* if the binary is not readable than enforce mm->dumpable=0
152 regardless of the interpreter's permissions */
153 if (permission(bprm
->file
->f_dentry
->d_inode
, MAY_READ
, NULL
))
154 bprm
->interp_flags
|= BINPRM_FLAGS_ENFORCE_NONDUMP
;
156 allow_write_access(bprm
->file
);
159 /* mark the bprm that fd should be passed to interp */
160 bprm
->interp_flags
|= BINPRM_FLAGS_EXECFD
;
161 bprm
->interp_data
= fd_binary
;
164 allow_write_access(bprm
->file
);
168 /* make argv[1] be the path to the binary */
169 retval
= copy_strings_kernel (1, &bprm
->interp
, bprm
);
174 /* add the interp as argv[0] */
175 retval
= copy_strings_kernel (1, &iname_addr
, bprm
);
180 bprm
->interp
= iname
; /* for binfmt_script */
182 interp_file
= open_exec (iname
);
183 retval
= PTR_ERR (interp_file
);
184 if (IS_ERR (interp_file
))
187 bprm
->file
= interp_file
;
188 if (fmt
->flags
& MISC_FMT_CREDENTIALS
) {
190 * No need to call prepare_binprm(), it's already been
191 * done. bprm->buf is stale, update from interp_file.
193 memset(bprm
->buf
, 0, BINPRM_BUF_SIZE
);
194 retval
= kernel_read(bprm
->file
, 0, bprm
->buf
, BINPRM_BUF_SIZE
);
196 retval
= prepare_binprm (bprm
);
201 retval
= search_binary_handler (bprm
, regs
);
207 put_files_struct(files
);
214 sys_close(fd_binary
);
215 bprm
->interp_flags
= 0;
216 bprm
->interp_data
= 0;
219 put_files_struct(current
->files
);
220 current
->files
= files
;
225 /* Command parsers */
228 * parses and copies one argument enclosed in del from *sp to *dp,
229 * recognising the \x special.
230 * returns pointer to the copied argument or NULL in case of an
231 * error (and sets err) or null argument length.
233 static char *scanarg(char *s
, char del
)
237 while ((c
= *s
++) != del
) {
238 if (c
== '\\' && *s
== 'x') {
249 static int unquote(char *from
)
251 char c
= 0, *s
= from
, *p
= from
;
253 while ((c
= *s
++) != '\0') {
254 if (c
== '\\' && *s
== 'x') {
257 *p
= (c
- (isdigit(c
) ? '0' : 'A' - 10)) << 4;
259 *p
++ |= c
- (isdigit(c
) ? '0' : 'A' - 10);
267 static inline char * check_special_flags (char * sfs
, Node
* e
)
277 e
->flags
|= MISC_FMT_PRESERVE_ARGV0
;
281 e
->flags
|= MISC_FMT_OPEN_BINARY
;
285 /* this flags also implies the
287 e
->flags
|= (MISC_FMT_CREDENTIALS
|
288 MISC_FMT_OPEN_BINARY
);
298 * This registers a new binary format, it recognises the syntax
299 * ':name:type:offset:magic:mask:interpreter:flags'
300 * where the ':' is the IFS, that can be chosen with the first char
302 static Node
*create_entry(const char __user
*buffer
, size_t count
)
309 /* some sanity checks */
311 if ((count
< 11) || (count
> 256))
315 memsize
= sizeof(Node
) + count
+ 8;
316 e
= (Node
*) kmalloc(memsize
, GFP_USER
);
320 p
= buf
= (char *)e
+ sizeof(Node
);
322 memset(e
, 0, sizeof(Node
));
323 if (copy_from_user(buf
, buffer
, count
))
326 del
= *p
++; /* delimeter */
328 memset(buf
+count
, del
, 8);
336 !strcmp(e
->name
, ".") ||
337 !strcmp(e
->name
, "..") ||
338 strchr(e
->name
, '/'))
341 case 'E': e
->flags
= 1<<Enabled
; break;
342 case 'M': e
->flags
= (1<<Enabled
) | (1<<Magic
); break;
343 default: goto Einval
;
347 if (test_bit(Magic
, &e
->flags
)) {
348 char *s
= strchr(p
, del
);
352 e
->offset
= simple_strtoul(p
, &p
, 10);
369 e
->size
= unquote(e
->magic
);
370 if (e
->mask
&& unquote(e
->mask
) != e
->size
)
372 if (e
->size
+ e
->offset
> BINPRM_BUF_SIZE
)
384 if (!e
->magic
[0] || strchr(e
->magic
, '/'))
396 if (!e
->interpreter
[0])
400 p
= check_special_flags (p
, e
);
404 if (p
!= buf
+ count
)
413 return ERR_PTR(-EFAULT
);
416 return ERR_PTR(-EINVAL
);
420 * Set status of entry/binfmt_misc:
421 * '1' enables, '0' disables and '-1' clears entry/binfmt_misc
423 static int parse_command(const char __user
*buffer
, size_t count
)
431 if (copy_from_user(s
, buffer
, count
))
433 if (s
[count
-1] == '\n')
435 if (count
== 1 && s
[0] == '0')
437 if (count
== 1 && s
[0] == '1')
439 if (count
== 2 && s
[0] == '-' && s
[1] == '1')
446 static void entry_status(Node
*e
, char *page
)
449 char *status
= "disabled";
450 const char * flags
= "flags: ";
452 if (test_bit(Enabled
, &e
->flags
))
455 if (!VERBOSE_STATUS
) {
456 sprintf(page
, "%s\n", status
);
460 sprintf(page
, "%s\ninterpreter %s\n", status
, e
->interpreter
);
461 dp
= page
+ strlen(page
);
463 /* print the special flags */
464 sprintf (dp
, "%s", flags
);
465 dp
+= strlen (flags
);
466 if (e
->flags
& MISC_FMT_PRESERVE_ARGV0
) {
469 if (e
->flags
& MISC_FMT_OPEN_BINARY
) {
472 if (e
->flags
& MISC_FMT_CREDENTIALS
) {
478 if (!test_bit(Magic
, &e
->flags
)) {
479 sprintf(dp
, "extension .%s\n", e
->magic
);
483 sprintf(dp
, "offset %i\nmagic ", e
->offset
);
484 dp
= page
+ strlen(page
);
485 for (i
= 0; i
< e
->size
; i
++) {
486 sprintf(dp
, "%02x", 0xff & (int) (e
->magic
[i
]));
490 sprintf(dp
, "\nmask ");
492 for (i
= 0; i
< e
->size
; i
++) {
493 sprintf(dp
, "%02x", 0xff & (int) (e
->mask
[i
]));
502 static struct inode
*bm_get_inode(struct super_block
*sb
, int mode
)
504 struct inode
* inode
= new_inode(sb
);
507 inode
->i_mode
= mode
;
510 inode
->i_blksize
= PAGE_CACHE_SIZE
;
512 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
517 static void bm_clear_inode(struct inode
*inode
)
519 kfree(inode
->u
.generic_ip
);
522 static void kill_node(Node
*e
)
524 struct dentry
*dentry
;
526 write_lock(&entries_lock
);
529 list_del_init(&e
->list
);
532 write_unlock(&entries_lock
);
535 dentry
->d_inode
->i_nlink
--;
538 simple_release_fs(&bm_mnt
, &entry_count
);
545 bm_entry_read(struct file
* file
, char __user
* buf
, size_t nbytes
, loff_t
*ppos
)
547 Node
*e
= file
->f_dentry
->d_inode
->u
.generic_ip
;
553 if (!(page
= (char*) __get_free_page(GFP_KERNEL
)))
556 entry_status(e
, page
);
565 if (len
< pos
+ nbytes
)
568 if (copy_to_user(buf
, page
+ pos
, nbytes
))
570 *ppos
= pos
+ nbytes
;
573 free_page((unsigned long) page
);
577 static ssize_t
bm_entry_write(struct file
*file
, const char __user
*buffer
,
578 size_t count
, loff_t
*ppos
)
581 Node
*e
= file
->f_dentry
->d_inode
->u
.generic_ip
;
582 int res
= parse_command(buffer
, count
);
585 case 1: clear_bit(Enabled
, &e
->flags
);
587 case 2: set_bit(Enabled
, &e
->flags
);
589 case 3: root
= dget(file
->f_vfsmnt
->mnt_sb
->s_root
);
590 down(&root
->d_inode
->i_sem
);
594 up(&root
->d_inode
->i_sem
);
602 static struct file_operations bm_entry_operations
= {
603 .read
= bm_entry_read
,
604 .write
= bm_entry_write
,
609 static ssize_t
bm_register_write(struct file
*file
, const char __user
*buffer
,
610 size_t count
, loff_t
*ppos
)
614 struct dentry
*root
, *dentry
;
615 struct super_block
*sb
= file
->f_vfsmnt
->mnt_sb
;
618 e
= create_entry(buffer
, count
);
623 root
= dget(sb
->s_root
);
624 down(&root
->d_inode
->i_sem
);
625 dentry
= lookup_one_len(e
->name
, root
, strlen(e
->name
));
626 err
= PTR_ERR(dentry
);
634 inode
= bm_get_inode(sb
, S_IFREG
| 0644);
640 err
= simple_pin_fs("binfmt_misc", &bm_mnt
, &entry_count
);
647 e
->dentry
= dget(dentry
);
648 inode
->u
.generic_ip
= e
;
649 inode
->i_fop
= &bm_entry_operations
;
651 d_instantiate(dentry
, inode
);
652 write_lock(&entries_lock
);
653 list_add(&e
->list
, &entries
);
654 write_unlock(&entries_lock
);
660 up(&root
->d_inode
->i_sem
);
670 static struct file_operations bm_register_operations
= {
671 .write
= bm_register_write
,
677 bm_status_read(struct file
*file
, char __user
*buf
, size_t nbytes
, loff_t
*ppos
)
679 char *s
= enabled
? "enabled" : "disabled";
687 if (len
< pos
+ nbytes
)
689 if (copy_to_user(buf
, s
+ pos
, nbytes
))
691 *ppos
= pos
+ nbytes
;
695 static ssize_t
bm_status_write(struct file
* file
, const char __user
* buffer
,
696 size_t count
, loff_t
*ppos
)
698 int res
= parse_command(buffer
, count
);
702 case 1: enabled
= 0; break;
703 case 2: enabled
= 1; break;
704 case 3: root
= dget(file
->f_vfsmnt
->mnt_sb
->s_root
);
705 down(&root
->d_inode
->i_sem
);
707 while (!list_empty(&entries
))
708 kill_node(list_entry(entries
.next
, Node
, list
));
710 up(&root
->d_inode
->i_sem
);
717 static struct file_operations bm_status_operations
= {
718 .read
= bm_status_read
,
719 .write
= bm_status_write
,
722 /* Superblock handling */
724 static struct super_operations s_ops
= {
725 .statfs
= simple_statfs
,
726 .clear_inode
= bm_clear_inode
,
729 static int bm_fill_super(struct super_block
* sb
, void * data
, int silent
)
731 static struct tree_descr bm_files
[] = {
732 [1] = {"status", &bm_status_operations
, S_IWUSR
|S_IRUGO
},
733 [2] = {"register", &bm_register_operations
, S_IWUSR
},
736 int err
= simple_fill_super(sb
, 0x42494e4d, bm_files
);
742 static struct super_block
*bm_get_sb(struct file_system_type
*fs_type
,
743 int flags
, const char *dev_name
, void *data
)
745 return get_sb_single(fs_type
, flags
, data
, bm_fill_super
);
748 static struct linux_binfmt misc_format
= {
749 .module
= THIS_MODULE
,
750 .load_binary
= load_misc_binary
,
753 static struct file_system_type bm_fs_type
= {
754 .owner
= THIS_MODULE
,
755 .name
= "binfmt_misc",
757 .kill_sb
= kill_litter_super
,
760 static int __init
init_misc_binfmt(void)
762 int err
= register_filesystem(&bm_fs_type
);
764 err
= register_binfmt(&misc_format
);
766 unregister_filesystem(&bm_fs_type
);
771 static void __exit
exit_misc_binfmt(void)
773 unregister_binfmt(&misc_format
);
774 unregister_filesystem(&bm_fs_type
);
777 core_initcall(init_misc_binfmt
);
778 module_exit(exit_misc_binfmt
);
779 MODULE_LICENSE("GPL");