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 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 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 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 * 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 * 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 * 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 * 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
Indexes created Sat Jun 20 00:25:23 UTC 2026