Loading...
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
22enum {
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
31static 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 */
49void 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 */
64static 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
72int 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 */
100int 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
204done:
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
217int 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}
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/fs_context.h>
16#include <linux/fs_parser.h>
17#include <linux/nls.h>
18#include <linux/mount.h>
19#include <linux/seq_file.h>
20#include <linux/slab.h>
21#include "hfsplus_fs.h"
22
23enum {
24 opt_creator, opt_type,
25 opt_umask, opt_uid, opt_gid,
26 opt_part, opt_session, opt_nls,
27 opt_decompose, opt_barrier,
28 opt_force,
29};
30
31static const struct fs_parameter_spec hfs_param_spec[] = {
32 fsparam_string ("creator", opt_creator),
33 fsparam_string ("type", opt_type),
34 fsparam_u32oct ("umask", opt_umask),
35 fsparam_u32 ("uid", opt_uid),
36 fsparam_u32 ("gid", opt_gid),
37 fsparam_u32 ("part", opt_part),
38 fsparam_u32 ("session", opt_session),
39 fsparam_string ("nls", opt_nls),
40 fsparam_flag_no ("decompose", opt_decompose),
41 fsparam_flag_no ("barrier", opt_barrier),
42 fsparam_flag ("force", opt_force),
43 {}
44};
45
46/* Initialize an options object to reasonable defaults */
47void hfsplus_fill_defaults(struct hfsplus_sb_info *opts)
48{
49 if (!opts)
50 return;
51
52 opts->creator = HFSPLUS_DEF_CR_TYPE;
53 opts->type = HFSPLUS_DEF_CR_TYPE;
54 opts->umask = current_umask();
55 opts->uid = current_uid();
56 opts->gid = current_gid();
57 opts->part = -1;
58 opts->session = -1;
59}
60
61/* Parse options from mount. Returns nonzero errno on failure */
62int hfsplus_parse_param(struct fs_context *fc, struct fs_parameter *param)
63{
64 struct hfsplus_sb_info *sbi = fc->s_fs_info;
65 struct fs_parse_result result;
66 int opt;
67
68 /*
69 * Only the force option is examined during remount, all others
70 * are ignored.
71 */
72 if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE &&
73 strncmp(param->key, "force", 5))
74 return 0;
75
76 opt = fs_parse(fc, hfs_param_spec, param, &result);
77 if (opt < 0)
78 return opt;
79
80 switch (opt) {
81 case opt_creator:
82 if (strlen(param->string) != 4) {
83 pr_err("creator requires a 4 character value\n");
84 return -EINVAL;
85 }
86 memcpy(&sbi->creator, param->string, 4);
87 break;
88 case opt_type:
89 if (strlen(param->string) != 4) {
90 pr_err("type requires a 4 character value\n");
91 return -EINVAL;
92 }
93 memcpy(&sbi->type, param->string, 4);
94 break;
95 case opt_umask:
96 sbi->umask = (umode_t)result.uint_32;
97 break;
98 case opt_uid:
99 sbi->uid = result.uid;
100 set_bit(HFSPLUS_SB_UID, &sbi->flags);
101 break;
102 case opt_gid:
103 sbi->gid = result.gid;
104 set_bit(HFSPLUS_SB_GID, &sbi->flags);
105 break;
106 case opt_part:
107 sbi->part = result.uint_32;
108 break;
109 case opt_session:
110 sbi->session = result.uint_32;
111 break;
112 case opt_nls:
113 if (sbi->nls) {
114 pr_err("unable to change nls mapping\n");
115 return -EINVAL;
116 }
117 sbi->nls = load_nls(param->string);
118 if (!sbi->nls) {
119 pr_err("unable to load nls mapping \"%s\"\n",
120 param->string);
121 return -EINVAL;
122 }
123 break;
124 case opt_decompose:
125 if (result.negated)
126 set_bit(HFSPLUS_SB_NODECOMPOSE, &sbi->flags);
127 else
128 clear_bit(HFSPLUS_SB_NODECOMPOSE, &sbi->flags);
129 break;
130 case opt_barrier:
131 if (result.negated)
132 set_bit(HFSPLUS_SB_NOBARRIER, &sbi->flags);
133 else
134 clear_bit(HFSPLUS_SB_NOBARRIER, &sbi->flags);
135 break;
136 case opt_force:
137 set_bit(HFSPLUS_SB_FORCE, &sbi->flags);
138 break;
139 default:
140 return -EINVAL;
141 }
142
143 return 0;
144}
145
146int hfsplus_show_options(struct seq_file *seq, struct dentry *root)
147{
148 struct hfsplus_sb_info *sbi = HFSPLUS_SB(root->d_sb);
149
150 if (sbi->creator != HFSPLUS_DEF_CR_TYPE)
151 seq_show_option_n(seq, "creator", (char *)&sbi->creator, 4);
152 if (sbi->type != HFSPLUS_DEF_CR_TYPE)
153 seq_show_option_n(seq, "type", (char *)&sbi->type, 4);
154 seq_printf(seq, ",umask=%o,uid=%u,gid=%u", sbi->umask,
155 from_kuid_munged(&init_user_ns, sbi->uid),
156 from_kgid_munged(&init_user_ns, sbi->gid));
157 if (sbi->part >= 0)
158 seq_printf(seq, ",part=%u", sbi->part);
159 if (sbi->session >= 0)
160 seq_printf(seq, ",session=%u", sbi->session);
161 if (sbi->nls)
162 seq_printf(seq, ",nls=%s", sbi->nls->charset);
163 if (test_bit(HFSPLUS_SB_NODECOMPOSE, &sbi->flags))
164 seq_puts(seq, ",nodecompose");
165 if (test_bit(HFSPLUS_SB_NOBARRIER, &sbi->flags))
166 seq_puts(seq, ",nobarrier");
167 return 0;
168}