contrib/amd/amd/am_ops.c

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