contrib/amd/amd/am_ops.c

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