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 }
144 break;
145 case opt_gid:
146 if (match_int(&args[0], &tmp)) {
147 pr_err("gid requires an argument\n");
148 return 0;
149 }
150 sbi->gid = make_kgid(current_user_ns(), (gid_t)tmp);
151 if (!gid_valid(sbi->gid)) {
152 pr_err("invalid gid specified\n");
153 return 0;
154 }
155 break;
156 case opt_part:
157 if (match_int(&args[0], &sbi->part)) {
158 pr_err("part requires an argument\n");
159 return 0;
160 }
161 break;
162 case opt_session:
163 if (match_int(&args[0], &sbi->session)) {
164 pr_err("session requires an argument\n");
165 return 0;
166 }
167 break;
168 case opt_nls:
169 if (sbi->nls) {
170 pr_err("unable to change nls mapping\n");
171 return 0;
172 }
173 p = match_strdup(&args[0]);
174 if (p)
175 sbi->nls = load_nls(p);
176 if (!sbi->nls) {
177 pr_err("unable to load nls mapping \"%s\"\n",
178 p);
179 kfree(p);
180 return 0;
181 }
182 kfree(p);
183 break;
184 case opt_decompose:
185 clear_bit(HFSPLUS_SB_NODECOMPOSE, &sbi->flags);
186 break;
187 case opt_nodecompose:
188 set_bit(HFSPLUS_SB_NODECOMPOSE, &sbi->flags);
189 break;
190 case opt_barrier:
191 clear_bit(HFSPLUS_SB_NOBARRIER, &sbi->flags);
192 break;
193 case opt_nobarrier:
194 set_bit(HFSPLUS_SB_NOBARRIER, &sbi->flags);
195 break;
196 case opt_force:
197 set_bit(HFSPLUS_SB_FORCE, &sbi->flags);
198 break;
199 default:
200 return 0;
201 }
202 }
203
204 done:
205 if (!sbi->nls) {
206 /* try utf8 first, as this is the old default behaviour */
207 sbi->nls = load_nls("utf8");
208 if (!sbi->nls)
209 sbi->nls = load_nls_default();
210 if (!sbi->nls)
211 return 0;
212 }
213
214 return 1;
215 }
216
hfsplus_show_options(struct seq_file * seq,struct dentry * root)217 int hfsplus_show_options(struct seq_file *seq, struct dentry *root)
218 {
219 struct hfsplus_sb_info *sbi = HFSPLUS_SB(root->d_sb);
220
221 if (sbi->creator != HFSPLUS_DEF_CR_TYPE)
222 seq_show_option_n(seq, "creator", (char *)&sbi->creator, 4);
223 if (sbi->type != HFSPLUS_DEF_CR_TYPE)
224 seq_show_option_n(seq, "type", (char *)&sbi->type, 4);
225 seq_printf(seq, ",umask=%o,uid=%u,gid=%u", sbi->umask,
226 from_kuid_munged(&init_user_ns, sbi->uid),
227 from_kgid_munged(&init_user_ns, sbi->gid));
228 if (sbi->part >= 0)
229 seq_printf(seq, ",part=%u", sbi->part);
230 if (sbi->session >= 0)
231 seq_printf(seq, ",session=%u", sbi->session);
232 if (sbi->nls)
233 seq_printf(seq, ",nls=%s", sbi->nls->charset);
234 if (test_bit(HFSPLUS_SB_NODECOMPOSE, &sbi->flags))
235 seq_puts(seq, ",nodecompose");
236 if (test_bit(HFSPLUS_SB_NOBARRIER, &sbi->flags))
237 seq_puts(seq, ",nobarrier");
238 return 0;
239 }
240