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 DEFINE_RWLOCK(entries_lock
);
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 (file_permission(bprm
->file
, MAY_READ
))
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
);
206 put_files_struct(files
);
213 sys_close(fd_binary
);
214 bprm
->interp_flags
= 0;
215 bprm
->interp_data
= 0;
218 put_files_struct(current
->files
);
219 current
->files
= files
;
224 /* Command parsers */
227 * parses and copies one argument enclosed in del from *sp to *dp,
228 * recognising the \x special.
229 * returns pointer to the copied argument or NULL in case of an
230 * error (and sets err) or null argument length.
232 static char *scanarg(char *s
, char del
)
236 while ((c
= *s
++) != del
) {
237 if (c
== '\\' && *s
== 'x') {
248 static int unquote(char *from
)
250 char c
= 0, *s
= from
, *p
= from
;
252 while ((c
= *s
++) != '\0') {
253 if (c
== '\\' && *s
== 'x') {
256 *p
= (c
- (isdigit(c
) ? '0' : 'A' - 10)) << 4;
258 *p
++ |= c
- (isdigit(c
) ? '0' : 'A' - 10);
266 static char * check_special_flags (char * sfs
, Node
* e
)
276 e
->flags
|= MISC_FMT_PRESERVE_ARGV0
;
280 e
->flags
|= MISC_FMT_OPEN_BINARY
;
284 /* this flags also implies the
286 e
->flags
|= (MISC_FMT_CREDENTIALS
|
287 MISC_FMT_OPEN_BINARY
);
297 * This registers a new binary format, it recognises the syntax
298 * ':name:type:offset:magic:mask:interpreter:flags'
299 * where the ':' is the IFS, that can be chosen with the first char
301 static Node
*create_entry(const char __user
*buffer
, size_t count
)
308 /* some sanity checks */
310 if ((count
< 11) || (count
> 256))
314 memsize
= sizeof(Node
) + count
+ 8;
315 e
= (Node
*) kmalloc(memsize
, GFP_USER
);
319 p
= buf
= (char *)e
+ sizeof(Node
);
321 memset(e
, 0, sizeof(Node
));
322 if (copy_from_user(buf
, buffer
, count
))
325 del
= *p
++; /* delimeter */
327 memset(buf
+count
, del
, 8);
335 !strcmp(e
->name
, ".") ||
336 !strcmp(e
->name
, "..") ||
337 strchr(e
->name
, '/'))
340 case 'E': e
->flags
= 1<<Enabled
; break;
341 case 'M': e
->flags
= (1<<Enabled
) | (1<<Magic
); break;
342 default: goto Einval
;
346 if (test_bit(Magic
, &e
->flags
)) {
347 char *s
= strchr(p
, del
);
351 e
->offset
= simple_strtoul(p
, &p
, 10);
368 e
->size
= unquote(e
->magic
);
369 if (e
->mask
&& unquote(e
->mask
) != e
->size
)
371 if (e
->size
+ e
->offset
> BINPRM_BUF_SIZE
)
383 if (!e
->magic
[0] || strchr(e
->magic
, '/'))
395 if (!e
->interpreter
[0])
399 p
= check_special_flags (p
, e
);
403 if (p
!= buf
+ count
)
412 return ERR_PTR(-EFAULT
);
415 return ERR_PTR(-EINVAL
);
419 * Set status of entry/binfmt_misc:
420 * '1' enables, '0' disables and '-1' clears entry/binfmt_misc
422 static int parse_command(const char __user
*buffer
, size_t count
)
430 if (copy_from_user(s
, buffer
, count
))
432 if (s
[count
-1] == '\n')
434 if (count
== 1 && s
[0] == '0')
436 if (count
== 1 && s
[0] == '1')
438 if (count
== 2 && s
[0] == '-' && s
[1] == '1')
445 static void entry_status(Node
*e
, char *page
)
448 char *status
= "disabled";
449 const char * flags
= "flags: ";
451 if (test_bit(Enabled
, &e
->flags
))
454 if (!VERBOSE_STATUS
) {
455 sprintf(page
, "%s\n", status
);
459 sprintf(page
, "%s\ninterpreter %s\n", status
, e
->interpreter
);
460 dp
= page
+ strlen(page
);
462 /* print the special flags */
463 sprintf (dp
, "%s", flags
);
464 dp
+= strlen (flags
);
465 if (e
->flags
& MISC_FMT_PRESERVE_ARGV0
) {
468 if (e
->flags
& MISC_FMT_OPEN_BINARY
) {
471 if (e
->flags
& MISC_FMT_CREDENTIALS
) {
477 if (!test_bit(Magic
, &e
->flags
)) {
478 sprintf(dp
, "extension .%s\n", e
->magic
);
482 sprintf(dp
, "offset %i\nmagic ", e
->offset
);
483 dp
= page
+ strlen(page
);
484 for (i
= 0; i
< e
->size
; i
++) {
485 sprintf(dp
, "%02x", 0xff & (int) (e
->magic
[i
]));
489 sprintf(dp
, "\nmask ");
491 for (i
= 0; i
< e
->size
; i
++) {
492 sprintf(dp
, "%02x", 0xff & (int) (e
->mask
[i
]));
501 static struct inode
*bm_get_inode(struct super_block
*sb
, int mode
)
503 struct inode
* inode
= new_inode(sb
);
506 inode
->i_mode
= mode
;
509 inode
->i_blksize
= PAGE_CACHE_SIZE
;
511 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
=
512 current_fs_time(inode
->i_sb
);
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 mutex_lock(&root
->d_inode
->i_mutex
);
594 mutex_unlock(&root
->d_inode
->i_mutex
);
602 static const 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 mutex_lock(&root
->d_inode
->i_mutex
);
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 mutex_unlock(&root
->d_inode
->i_mutex
);
670 static const 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 mutex_lock(&root
->d_inode
->i_mutex
);
707 while (!list_empty(&entries
))
708 kill_node(list_entry(entries
.next
, Node
, list
));
710 mutex_unlock(&root
->d_inode
->i_mutex
);
717 static const 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 int bm_get_sb(struct file_system_type
*fs_type
,
743 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
745 return get_sb_single(fs_type
, flags
, data
, bm_fill_super
, mnt
);
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");