1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *  linux/fs/hfsplus/options.c
4  *
5  * Copyright (C) 2001
6  * Brad Boyer (flar@allandria.com)
7  * (C) 2003 Ardis Technologies <roman@ardistech.com>
8  *
9  * Option parsing
10  */
11 
12 #include <linux/string.h>
13 #include <linux/kernel.h>
14 #include <linux/sched.h>
15 #include <linux/parser.h>
16 #include <linux/nls.h>
17 #include <linux/mount.h>
18 #include <linux/seq_file.h>
19 #include <linux/slab.h>
20 #include "hfsplus_fs.h"
21 
22 enum {
23 	opt_creator, opt_type,
24 	opt_umask, opt_uid, opt_gid,
25 	opt_part, opt_session, opt_nls,
26 	opt_nodecompose, opt_decompose,
27 	opt_barrier, opt_nobarrier,
28 	opt_force, opt_err
29 };
30 
31 static const match_table_t tokens = {
32 	{ opt_creator, "creator=%s" },
33 	{ opt_type, "type=%s" },
34 	{ opt_umask, "umask=%o" },
35 	{ opt_uid, "uid=%u" },
36 	{ opt_gid, "gid=%u" },
37 	{ opt_part, "part=%u" },
38 	{ opt_session, "session=%u" },
39 	{ opt_nls, "nls=%s" },
40 	{ opt_decompose, "decompose" },
41 	{ opt_nodecompose, "nodecompose" },
42 	{ opt_barrier, "barrier" },
43 	{ opt_nobarrier, "nobarrier" },
44 	{ opt_force, "force" },
45 	{ opt_err, NULL }
46 };
47 
48 /* Initialize an options object to reasonable defaults */
hfsplus_fill_defaults(struct hfsplus_sb_info * opts)49 void hfsplus_fill_defaults(struct hfsplus_sb_info *opts)
50 {
51 	if (!opts)
52 		return;
53 
54 	opts->creator = HFSPLUS_DEF_CR_TYPE;
55 	opts->type = HFSPLUS_DEF_CR_TYPE;
56 	opts->umask = current_umask();
57 	opts->uid = current_uid();
58 	opts->gid = current_gid();
59 	opts->part = -1;
60 	opts->session = -1;
61 }
62 
63 /* convert a "four byte character" to a 32 bit int with error checks */
match_fourchar(substring_t * arg,u32 * result)64 static inline int match_fourchar(substring_t *arg, u32 *result)
65 {
66 	if (arg->to - arg->from != 4)
67 		return -EINVAL;
68 	memcpy(result, arg->from, 4);
69 	return 0;
70 }
71 
hfsplus_parse_options_remount(char * input,int * force)72 int hfsplus_parse_options_remount(char *input, int *force)
73 {
74 	char *p;
75 	substring_t args[MAX_OPT_ARGS];
76 	int token;
77 
78 	if (!input)
79 		return 1;
80 
81 	while ((p = strsep(&input, ",")) != NULL) {
82 		if (!*p)
83 			continue;
84 
85 		token = match_token(p, tokens, args);
86 		switch (token) {
87 		case opt_force:
88 			*force = 1;
89 			break;
90 		default:
91 			break;
92 		}
93 	}
94 
95 	return 1;
96 }
97 
98 /* Parse options from mount. Returns 0 on failure */
99 /* input is the options passed to mount() as a string */
hfsplus_parse_options(char * input,struct hfsplus_sb_info * sbi)100 int hfsplus_parse_options(char *input, struct hfsplus_sb_info *sbi)
101 {
102 	char *p;
103 	substring_t args[MAX_OPT_ARGS];
104 	int tmp, token;
105 
106 	if (!input)
107 		goto done;
108 
109 	while ((p = strsep(&input, ",")) != NULL) {
110 		if (!*p)
111 			continue;
112 
113 		token = match_token(p, tokens, args);
114 		switch (token) {
115 		case opt_creator:
116 			if (match_fourchar(&args[0], &sbi->creator)) {
117 				pr_err("creator requires a 4 character value\n");
118 				return 0;
119 			}
120 			break;
121 		case opt_type:
122 			if (match_fourchar(&args[0], &sbi->type)) {
123 				pr_err("type requires a 4 character value\n");
124 				return 0;
125 			}
126 			break;
127 		case opt_umask:
128 			if (match_octal(&args[0], &tmp)) {
129 				pr_err("umask requires a value\n");
130 				return 0;
131 			}
132 			sbi->umask = (umode_t)tmp;
133 			break;
134 		case opt_uid:
135 			if (match_int(&args[0], &tmp)) {
136 				pr_err("uid requires an argument\n");
137 				return 0;
138 			}
139 			sbi->uid = make_kuid(current_user_ns(), (uid_t)tmp);
140 			if (!uid_valid(sbi->uid)) {
141 				pr_err("invalid uid specified\n");
142 				return 0;
143 			} else {
144 				set_bit(HFSPLUS_SB_UID, &sbi->flags);
145 			}
146 			break;
147 		case opt_gid:
148 			if (match_int(&args[0], &tmp)) {
149 				pr_err("gid requires an argument\n");
150 				return 0;
151 			}
152 			sbi->gid = make_kgid(current_user_ns(), (gid_t)tmp);
153 			if (!gid_valid(sbi->gid)) {
154 				pr_err("invalid gid specified\n");
155 				return 0;
156 			} else {
157 				set_bit(HFSPLUS_SB_GID, &sbi->flags);
158 			}
159 			break;
160 		case opt_part:
161 			if (match_int(&args[0], &sbi->part)) {
162 				pr_err("part requires an argument\n");
163 				return 0;
164 			}
165 			break;
166 		case opt_session:
167 			if (match_int(&args[0], &sbi->session)) {
168 				pr_err("session requires an argument\n");
169 				return 0;
170 			}
171 			break;
172 		case opt_nls:
173 			if (sbi->nls) {
174 				pr_err("unable to change nls mapping\n");
175 				return 0;
176 			}
177 			p = match_strdup(&args[0]);
178 			if (p)
179 				sbi->nls = load_nls(p);
180 			if (!sbi->nls) {
181 				pr_err("unable to load nls mapping \"%s\"\n",
182 				       p);
183 				kfree(p);
184 				return 0;
185 			}
186 			kfree(p);
187 			break;
188 		case opt_decompose:
189 			clear_bit(HFSPLUS_SB_NODECOMPOSE, &sbi->flags);
190 			break;
191 		case opt_nodecompose:
192 			set_bit(HFSPLUS_SB_NODECOMPOSE, &sbi->flags);
193 			break;
194 		case opt_barrier:
195 			clear_bit(HFSPLUS_SB_NOBARRIER, &sbi->flags);
196 			break;
197 		case opt_nobarrier:
198 			set_bit(HFSPLUS_SB_NOBARRIER, &sbi->flags);
199 			break;
200 		case opt_force:
201 			set_bit(HFSPLUS_SB_FORCE, &sbi->flags);
202 			break;
203 		default:
204 			return 0;
205 		}
206 	}
207 
208 done:
209 	if (!sbi->nls) {
210 		/* try utf8 first, as this is the old default behaviour */
211 		sbi->nls = load_nls("utf8");
212 		if (!sbi->nls)
213 			sbi->nls = load_nls_default();
214 		if (!sbi->nls)
215 			return 0;
216 	}
217 
218 	return 1;
219 }
220 
hfsplus_show_options(struct seq_file * seq,struct dentry * root)221 int hfsplus_show_options(struct seq_file *seq, struct dentry *root)
222 {
223 	struct hfsplus_sb_info *sbi = HFSPLUS_SB(root->d_sb);
224 
225 	if (sbi->creator != HFSPLUS_DEF_CR_TYPE)
226 		seq_show_option_n(seq, "creator", (char *)&sbi->creator, 4);
227 	if (sbi->type != HFSPLUS_DEF_CR_TYPE)
228 		seq_show_option_n(seq, "type", (char *)&sbi->type, 4);
229 	seq_printf(seq, ",umask=%o,uid=%u,gid=%u", sbi->umask,
230 			from_kuid_munged(&init_user_ns, sbi->uid),
231 			from_kgid_munged(&init_user_ns, sbi->gid));
232 	if (sbi->part >= 0)
233 		seq_printf(seq, ",part=%u", sbi->part);
234 	if (sbi->session >= 0)
235 		seq_printf(seq, ",session=%u", sbi->session);
236 	if (sbi->nls)
237 		seq_printf(seq, ",nls=%s", sbi->nls->charset);
238 	if (test_bit(HFSPLUS_SB_NODECOMPOSE, &sbi->flags))
239 		seq_puts(seq, ",nodecompose");
240 	if (test_bit(HFSPLUS_SB_NOBARRIER, &sbi->flags))
241 		seq_puts(seq, ",nobarrier");
242 	return 0;
243 }
244