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 */
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 */
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
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 */
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
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
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.