1 /* $NetBSD: am_ops.c,v 1.1.1.3 2015/01/17 16:34:15 christos Exp $ */
2
3 /*
4 * Copyright (c) 1997-2014 Erez Zadok
5 * Copyright (c) 1989 Jan-Simon Pendry
6 * Copyright (c) 1989 Imperial College of Science, Technology & Medicine
7 * Copyright (c) 1989 The Regents of the University of California.
8 * All rights reserved.
9 *
10 * This code is derived from software contributed to Berkeley by
11 * Jan-Simon Pendry at Imperial College, London.
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
15 * are met:
16 * 1. Redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 * notice, this list of conditions and the following disclaimer in the
20 * documentation and/or other materials provided with the distribution.
21 * 3. Neither the name of the University nor the names of its contributors
22 * may be used to endorse or promote products derived from this software
23 * without specific prior written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 * SUCH DAMAGE.
36 *
37 *
38 * File: am-utils/amd/am_ops.c
39 *
40 */
41
42 #ifdef HAVE_CONFIG_H
43 # include <config.h>
44 #endif /* HAVE_CONFIG_H */
45 #include <am_defs.h>
46 #include <amd.h>
47
48
49 /*
50 * The order of these entries matters, since lookups in this table are done
51 * on a first-match basis. The entries below are a mixture of native
52 * filesystems supported by the OS (HAVE_FS_FOO), and some meta-filesystems
53 * supported by amd (HAVE_AMU_FS_FOO). The order is set here in expected
54 * match-hit such that more popular filesystems are listed first (nfs is the
55 * most popular, followed by a symlink F/S)
56 */
57 static am_ops *vops[] =
58 {
59 #ifdef HAVE_FS_NFS
60 &nfs_ops, /* network F/S (version 2) */
61 #endif /* HAVE_FS_NFS */
62 #ifdef HAVE_AMU_FS_LINK
63 &amfs_link_ops, /* symlink F/S */
64 #endif /* HAVE_AMU_FS_LINK */
65
66 /*
67 * Other amd-supported meta-filesystems.
68 */
69 #ifdef HAVE_AMU_FS_NFSX
70 &amfs_nfsx_ops, /* multiple-nfs F/S */
71 #endif /* HAVE_AMU_FS_NFSX */
72 #ifdef HAVE_AMU_FS_NFSL
73 &amfs_nfsl_ops, /* NFS with local link existence check */
74 #endif /* HAVE_AMU_FS_NFSL */
75 #ifdef HAVE_AMU_FS_HOST
76 &amfs_host_ops, /* multiple exported nfs F/S */
77 #endif /* HAVE_AMU_FS_HOST */
78 #ifdef HAVE_AMU_FS_LINKX
79 &amfs_linkx_ops, /* symlink F/S with link target verify */
80 #endif /* HAVE_AMU_FS_LINKX */
81 #ifdef HAVE_AMU_FS_PROGRAM
82 &amfs_program_ops, /* program F/S */
83 #endif /* HAVE_AMU_FS_PROGRAM */
84 #ifdef HAVE_AMU_FS_UNION
85 &amfs_union_ops, /* union F/S */
86 #endif /* HAVE_AMU_FS_UNION */
87
88 /*
89 * A few more native filesystems.
90 */
91 #ifdef HAVE_FS_UFS
92 &ufs_ops, /* Unix F/S */
93 #endif /* HAVE_FS_UFS */
94 #ifdef HAVE_FS_XFS
95 &xfs_ops, /* Unix (irix) F/S */
96 #endif /* HAVE_FS_XFS */
97 #ifdef HAVE_FS_EXT
98 &ext2_ops, /* Unix (linux) F/S */
99 &ext3_ops, /* Unix (linux) F/S */
100 &ext4_ops, /* Unix (linux) F/S */
101 #endif /* HAVE_FS_EXT */
102 #ifdef HAVE_FS_EFS
103 &efs_ops, /* Unix (irix) F/S */
104 #endif /* HAVE_FS_EFS */
105 #ifdef HAVE_FS_LOFS
106 &lofs_ops, /* loopback F/S */
107 #endif /* HAVE_FS_LOFS */
108 #ifdef HAVE_FS_CDFS
109 &cdfs_ops, /* CDROM/HSFS/ISO9960 F/S */
110 #endif /* HAVE_FS_CDFS */
111 #ifdef HAVE_FS_PCFS
112 &pcfs_ops, /* Floppy/MSDOS F/S */
113 #endif /* HAVE_FS_PCFS */
114 #ifdef HAVE_FS_CACHEFS
115 &cachefs_ops, /* caching F/S */
116 #endif /* HAVE_FS_CACHEFS */
117 #ifdef HAVE_FS_TMPFS
118 &tmpfs_ops, /* /tmp (in memory) F/S */
119 #endif /* HAVE_FS_TMPFS */
120 #ifdef HAVE_FS_NULLFS
121 /* FILL IN */ /* null (loopback) F/S */
122 #endif /* HAVE_FS_NULLFS */
123 #ifdef HAVE_FS_UNIONFS
124 /* FILL IN */ /* union (bsd44) F/S */
125 #endif /* HAVE_FS_UNIONFS */
126 #ifdef HAVE_FS_UMAPFS
127 /* FILL IN */ /* uid/gid mapping F/S */
128 #endif /* HAVE_FS_UMAPFS */
129 #ifdef HAVE_FS_UDF
130 &udf_ops, /* UDF F/S */
131 #endif /* HAVE_FS_UDF */
132 #ifdef HAVE_FS_LUSTRE
133 &lustre_ops, /* Lustre */
134 #endif /* HAVE_FS_LUSTRE */
135
136 /*
137 * These 4 should be last, in the order:
138 * (1) amfs_auto
139 * (2) amfs_direct
140 * (3) amfs_toplvl
141 * (4) amfs_error
142 */
143 #ifdef HAVE_AMU_FS_AUTO
144 &amfs_auto_ops, /* Automounter F/S */
145 #endif /* HAVE_AMU_FS_AUTO */
146 #ifdef HAVE_AMU_FS_DIRECT
147 &amfs_direct_ops, /* direct-mount F/S */
148 #endif /* HAVE_AMU_FS_DIRECT */
149 #ifdef HAVE_AMU_FS_TOPLVL
150 &amfs_toplvl_ops, /* top-level mount F/S */
151 #endif /* HAVE_AMU_FS_TOPLVL */
152 #ifdef HAVE_AMU_FS_ERROR
153 &amfs_error_ops, /* error F/S */
154 #endif /* HAVE_AMU_FS_ERROR */
155 0
156 };
157
158
159 void
ops_showamfstypes(char * buf,size_t l)160 ops_showamfstypes(char *buf, size_t l)
161 {
162 struct am_ops **ap;
163 int linesize = 0;
164
165 buf[0] = '\0';
166 for (ap = vops; *ap; ap++) {
167 xstrlcat(buf, (*ap)->fs_type, l);
168 if (ap[1])
169 xstrlcat(buf, ", ", l);
170 linesize += strlen((*ap)->fs_type) + 2;
171 if (linesize > 62) {
172 linesize = 0;
173 xstrlcat(buf, "\n ", l);
174 }
175 }
176 }
177
178
179 static void
ops_show1(char * buf,size_t l,int * linesizep,const char * name)180 ops_show1(char *buf, size_t l, int *linesizep, const char *name)
181 {
182 xstrlcat(buf, name, l);
183 xstrlcat(buf, ", ", l);
184 *linesizep += strlen(name) + 2;
185 if (*linesizep > 60) {
186 xstrlcat(buf, "\t\n", l);
187 *linesizep = 0;
188 }
189 }
190
191
192 void
ops_showfstypes(char * buf,size_t l)193 ops_showfstypes(char *buf, size_t l)
194 {
195 int linesize = 0;
196
197 buf[0] = '\0';
198
199 #ifdef MNTTAB_TYPE_AUTOFS
200 ops_show1(buf, l, &linesize, MNTTAB_TYPE_AUTOFS);
201 #endif /* MNTTAB_TYPE_AUTOFS */
202
203 #ifdef MNTTAB_TYPE_CACHEFS
204 ops_show1(buf, l, &linesize, MNTTAB_TYPE_CACHEFS);
205 #endif /* MNTTAB_TYPE_CACHEFS */
206
207 #ifdef MNTTAB_TYPE_CDFS
208 ops_show1(buf, l, &linesize, MNTTAB_TYPE_CDFS);
209 #endif /* MNTTAB_TYPE_CDFS */
210
211 #ifdef MNTTAB_TYPE_CFS
212 ops_show1(buf, l, &linesize, MNTTAB_TYPE_CFS);
213 #endif /* MNTTAB_TYPE_CFS */
214
215 #ifdef MNTTAB_TYPE_LOFS
216 ops_show1(buf, l, &linesize, MNTTAB_TYPE_LOFS);
217 #endif /* MNTTAB_TYPE_LOFS */
218
219 #ifdef MNTTAB_TYPE_EFS
220 ops_show1(buf, l, &linesize, MNTTAB_TYPE_EFS);
221 #endif /* MNTTAB_TYPE_EFS */
222
223 #ifdef MNTTAB_TYPE_MFS
224 ops_show1(buf, l, &linesize, MNTTAB_TYPE_MFS);
225 #endif /* MNTTAB_TYPE_MFS */
226
227 #ifdef MNTTAB_TYPE_NFS
228 ops_show1(buf, l, &linesize, MNTTAB_TYPE_NFS);
229 #endif /* MNTTAB_TYPE_NFS */
230
231 #ifdef MNTTAB_TYPE_NFS3
232 ops_show1(buf, l, &linesize, "nfs3"); /* always hard-code as nfs3 */
233 #endif /* MNTTAB_TYPE_NFS3 */
234
235 #ifdef MNTTAB_TYPE_NULLFS
236 ops_show1(buf, l, &linesize, MNTTAB_TYPE_NULLFS);
237 #endif /* MNTTAB_TYPE_NULLFS */
238
239 #ifdef MNTTAB_TYPE_PCFS
240 ops_show1(buf, l, &linesize, MNTTAB_TYPE_PCFS);
241 #endif /* MNTTAB_TYPE_PCFS */
242
243 #ifdef MNTTAB_TYPE_TFS
244 ops_show1(buf, l, &linesize, MNTTAB_TYPE_TFS);
245 #endif /* MNTTAB_TYPE_TFS */
246
247 #ifdef MNTTAB_TYPE_TMPFS
248 ops_show1(buf, l, &linesize, MNTTAB_TYPE_TMPFS);
249 #endif /* MNTTAB_TYPE_TMPFS */
250
251 #ifdef MNTTAB_TYPE_UFS
252 ops_show1(buf, l, &linesize, MNTTAB_TYPE_UFS);
253 #endif /* MNTTAB_TYPE_UFS */
254
255 #ifdef MNTTAB_TYPE_UMAPFS
256 ops_show1(buf, l, &linesize, MNTTAB_TYPE_UMAPFS);
257 #endif /* MNTTAB_TYPE_UMAPFS */
258
259 #ifdef MNTTAB_TYPE_UNIONFS
260 ops_show1(buf, l, &linesize, MNTTAB_TYPE_UNIONFS);
261 #endif /* MNTTAB_TYPE_UNIONFS */
262
263 #ifdef MNTTAB_TYPE_XFS
264 ops_show1(buf, l, &linesize, MNTTAB_TYPE_XFS);
265 #endif /* MNTTAB_TYPE_XFS */
266
267 /* terminate with a period, newline, and NULL */
268 if (buf[strlen(buf)-1] == '\n')
269 buf[strlen(buf) - 4] = '\0';
270 else
271 buf[strlen(buf) - 2] = '\0';
272 xstrlcat(buf, ".\n", l);
273 }
274
275
276 /*
277 * return string option which is the reverse of opt.
278 * nosuid -> suid
279 * quota -> noquota
280 * ro -> rw
281 * etc.
282 * may return pointer to static buffer or subpointer within opt.
283 */
284 static char *
reverse_option(const char * opt)285 reverse_option(const char *opt)
286 {
287 static char buf[80];
288
289 /* sanity check */
290 if (!opt)
291 return NULL;
292
293 /* check special cases */
294 /* XXX: if this gets too long, rewrite the code more flexibly */
295 if (STREQ(opt, "ro")) return "rw";
296 if (STREQ(opt, "rw")) return "ro";
297 if (STREQ(opt, "bg")) return "fg";
298 if (STREQ(opt, "fg")) return "bg";
299 if (STREQ(opt, "soft")) return "hard";
300 if (STREQ(opt, "hard")) return "soft";
301
302 /* check if string starts with 'no' and chop it */
303 if (NSTREQ(opt, "no", 2)) {
304 xstrlcpy(buf, &opt[2], sizeof(buf));
305 } else {
306 /* finally return a string prepended with 'no' */
307 xstrlcpy(buf, "no", sizeof(buf));
308 xstrlcat(buf, opt, sizeof(buf));
309 }
310 return buf;
311 }
312
313
314 /*
315 * start with an empty string. for each opts1 option that is not
316 * in opts2, add it to the string (make sure the reverse of it
317 * isn't in either). finally add opts2. return new string.
318 * Both opts1 and opts2 must not be null!
319 * Caller must eventually free the string being returned.
320 */
321 static char *
merge_opts(const char * opts1,const char * opts2)322 merge_opts(const char *opts1, const char *opts2)
323 {
324 mntent_t mnt2; /* place holder for opts2 */
325 char *newstr; /* new string to return (malloc'ed) */
326 char *tmpstr; /* temp */
327 char *eq; /* pointer to whatever follows '=' within temp */
328 char oneopt[80]; /* one option w/o value if any */
329 char *revoneopt; /* reverse of oneopt */
330 size_t len = strlen(opts1) + strlen(opts2) + 2; /* space for "," and NULL */
331 char *s1 = xstrdup(opts1); /* copy of opts1 to munge */
332
333 /* initialization */
334 mnt2.mnt_opts = (char *) opts2;
335 newstr = xmalloc(len);
336 newstr[0] = '\0';
337
338 for (tmpstr = strtok(s1, ",");
339 tmpstr;
340 tmpstr = strtok(NULL, ",")) {
341 /* copy option to temp buffer */
342 xstrlcpy(oneopt, tmpstr, sizeof(oneopt));
343 /* if option has a value such as rsize=1024, chop the value part */
344 if ((eq = strchr(oneopt, '=')))
345 *eq = '\0';
346 /* find reverse option of oneopt */
347 revoneopt = reverse_option(oneopt);
348 /* if option or its reverse exist in opts2, ignore it */
349 if (amu_hasmntopt(&mnt2, oneopt) || amu_hasmntopt(&mnt2, revoneopt))
350 continue;
351 /* add option to returned string */
352 if (newstr[0]) {
353 xstrlcat(newstr, ",", len);
354 xstrlcat(newstr, tmpstr, len);
355 } else {
356 xstrlcpy(newstr, tmpstr, len);
357 }
358 }
359
360 /* finally, append opts2 itself */
361 if (newstr[0]) {
362 xstrlcat(newstr, ",", len);
363 xstrlcat(newstr, opts2, len);
364 } else {
365 xstrlcpy(newstr, opts2, len);
366 }
367
368 XFREE(s1);
369 return newstr;
370 }
371
372
373 am_ops *
ops_search(char * type)374 ops_search(char *type)
375 {
376 am_ops **vp;
377 am_ops *rop = NULL;
378 for (vp = vops; (rop = *vp); vp++)
379 if (STREQ(rop->fs_type, type))
380 break;
381 return rop;
382 }
383
384
385 am_ops *
ops_match(am_opts * fo,char * key,char * g_key,char * path,char * keym,char * map)386 ops_match(am_opts *fo, char *key, char *g_key, char *path, char *keym, char *map)
387 {
388 am_ops *rop = NULL;
389 char *link_dir;
390
391 /*
392 * First crack the global opts and the local opts
393 */
394 if (!eval_fs_opts(fo, key, g_key, path, keym, map)) {
395 rop = &amfs_error_ops;
396 } else if (fo->opt_type == 0) {
397 plog(XLOG_USER, "No fs type specified (key = \"%s\", map = \"%s\")", keym, map);
398 rop = &amfs_error_ops;
399 } else {
400 /*
401 * Next find the correct filesystem type
402 */
403 rop = ops_search(fo->opt_type);
404 if (!rop) {
405 plog(XLOG_USER, "fs type \"%s\" not recognized", fo->opt_type);
406 rop = &amfs_error_ops;
407 }
408 }
409
410 /*
411 * Make sure we have a default mount option.
412 * Otherwise skip past any leading '-'.
413 */
414 if (fo->opt_opts == 0)
415 fo->opt_opts = xstrdup("rw,defaults");
416 else if (*fo->opt_opts == '-') {
417 /*
418 * We cannot simply do fo->opt_opts++ here since the opts
419 * module will try to free the pointer fo->opt_opts later.
420 * So just reallocate the thing -- stolcke 11/11/94
421 */
422 char *old = fo->opt_opts;
423 fo->opt_opts = xstrdup(old + 1);
424 XFREE(old);
425 }
426
427 /*
428 * If addopts option was used, then append it to the
429 * current options and remote mount options.
430 */
431 if (fo->opt_addopts) {
432 if (STREQ(fo->opt_opts, fo->opt_remopts)) {
433 /* optimize things for the common case where opts==remopts */
434 char *mergedstr;
435 mergedstr = merge_opts(fo->opt_opts, fo->opt_addopts);
436 plog(XLOG_INFO, "merge rem/opts \"%s\" add \"%s\" => \"%s\"",
437 fo->opt_opts, fo->opt_addopts, mergedstr);
438 XFREE(fo->opt_opts);
439 XFREE(fo->opt_remopts);
440 fo->opt_opts = mergedstr;
441 fo->opt_remopts = xstrdup(mergedstr);
442 } else {
443 char *mergedstr, *remmergedstr;
444 mergedstr = merge_opts(fo->opt_opts, fo->opt_addopts);
445 plog(XLOG_INFO, "merge opts \"%s\" add \"%s\" => \"%s\"",
446 fo->opt_opts, fo->opt_addopts, mergedstr);
447 XFREE(fo->opt_opts);
448 fo->opt_opts = mergedstr;
449 remmergedstr = merge_opts(fo->opt_remopts, fo->opt_addopts);
450 plog(XLOG_INFO, "merge remopts \"%s\" add \"%s\" => \"%s\"",
451 fo->opt_remopts, fo->opt_addopts, remmergedstr);
452 XFREE(fo->opt_remopts);
453 fo->opt_remopts = remmergedstr;
454 }
455 }
456
457 /*
458 * Initialize opt_mount_type to "nfs", if it's not initialized already
459 */
460 if (!fo->opt_mount_type)
461 fo->opt_mount_type = "nfs";
462
463 /* Normalize the sublink and make it absolute */
464 link_dir = fo->opt_sublink;
465 if (link_dir && link_dir[0] && link_dir[0] != '/') {
466 link_dir = str3cat((char *) NULL, fo->opt_fs, "/", link_dir);
467 normalize_slash(link_dir);
468 XFREE(fo->opt_sublink);
469 fo->opt_sublink = link_dir;
470 }
471
472 /*
473 * Check the filesystem is happy
474 */
475 XFREE(fo->fs_mtab);
476
477 fo->fs_mtab = rop->fs_match(fo);
478 if (fo->fs_mtab)
479 return rop;
480
481 /*
482 * Return error file system
483 */
484 fo->fs_mtab = amfs_error_ops.fs_match(fo);
485 return &amfs_error_ops;
486 }
487