external/bsd/am-utils/dist/amd/am_ops.c

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