8322 nl: misleading-indentation

[unleashed/tickless.git] / usr / src / cmd / fs.d / ufs / mount / mount.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*        All Rights Reserved   */

/*
 * University Copyright- Copyright (c) 1982, 1986, 1988
 * The Regents of the University of California
 * All Rights Reserved
 *
 * University Acknowledgment- Portions of this document are derived from
 * software developed by the University of California, Berkeley, and its
 * contributors.
 */

/*
 * mount
 */
#include <ctype.h>
#include <string.h>
#include <fcntl.h>
#include <signal.h>
#include <poll.h>
#include <sys/mkdev.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/mntent.h>
#include <stdlib.h>

#define bcopy(f, t, n)  memcpy(t, f, n)
#define bzero(s, n)     memset(s, 0, n)
#define bcmp(s, d, n)   memcmp(s, d, n)

#define index(s, r)     strchr(s, r)
#define rindex(s, r)    strrchr(s, r)

#include <errno.h>
#include <sys/vfs.h>
#include <sys/stat.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/mnttab.h>
#include <sys/mount.h>
#include <sys/mntio.h>
#include <sys/wait.h>
#include <sys/fstyp.h>
#include <sys/fsid.h>
#include <sys/vfstab.h>
#include <sys/filio.h>
#include <sys/fs/ufs_fs.h>

#include <sys/fs/ufs_mount.h>
#include <sys/fs/ufs_filio.h>

#include <locale.h>
#include <fslib.h>

static int      ro = 0;
static int      largefiles = 0; /* flag - add default nolargefiles to mnttab */

static int      gflg = 0;
static int      mflg = 0;
static int      Oflg = 0;
static int      qflg = 0;

#define NAME_MAX        64              /* sizeof "fstype myname" */

static int      checkislog(char *);
static void     disable_logging(char *, char *);
static int      eatmntopt(struct mnttab *, char *);
static void     enable_logging(char *, char *);
static void     fixopts(struct mnttab *, char *);
static void     mountfs(struct mnttab *);
static void     replace_opts(char *, int, char *, char *);
static int      replace_opts_dflt(char *, int, const char *, const char *);
static void     rmopt(struct mnttab *, char *);
static void     rpterr(char *, char *);
static void     usage(void);

static char     fstype[] = MNTTYPE_UFS;
static char     opts[MAX_MNTOPT_STR];
static char     typename[NAME_MAX], *myname;
static char     *fop_subopts[] = { MNTOPT_ONERROR, NULL };
#define NOMATCH (-1)
#define ONERROR (0)             /* index within fop_subopts */

static struct fop_subopt {
        char    *str;
        int      flag;
} fop_subopt_list[] = {
        { UFSMNT_ONERROR_PANIC_STR,     UFSMNT_ONERROR_PANIC    },
        { UFSMNT_ONERROR_LOCK_STR,      UFSMNT_ONERROR_LOCK     },
        { UFSMNT_ONERROR_UMOUNT_STR,    UFSMNT_ONERROR_UMOUNT   },
        { NULL,                         UFSMNT_ONERROR_DEFAULT  }
};


/*
 * Check if the specified filesystem is already mounted.
 */
static boolean_t
in_mnttab(char *mountp)
{
        FILE *file;
        int found = B_FALSE;
        struct mnttab mntent;

        if ((file = fopen(MNTTAB, "r")) == NULL)
                return (B_FALSE);
        while (getmntent(file, &mntent) == 0) {
                if (mntent.mnt_mountp != NULL &&
                    strcmp(mntent.mnt_mountp, mountp) == 0 &&
                    mntent.mnt_fstype != NULL &&
                    strcmp(mntent.mnt_fstype, MNTTYPE_UFS) == 0) {
                        found = B_TRUE;
                        break;
                }
        }
        (void) fclose(file);
        return (found);
}

/*
 * Find opt in mntopt
 */
static char *
findopt(char *mntopt, char *opt)
{
        int nc, optlen = strlen(opt);

        while (*mntopt) {
                nc = strcspn(mntopt, ", =");
                if (strncmp(mntopt, opt, nc) == 0)
                        if (optlen == nc)
                                return (mntopt);
                mntopt += nc;
                mntopt += strspn(mntopt, ", =");
        }
        return (NULL);
}

int
main(int argc, char *argv[])
{
        struct mnttab mnt;
        int     c;

        (void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN     "SYS_TEST"
#endif
        (void) textdomain(TEXT_DOMAIN);

        myname = strrchr(argv[0], '/');
        if (myname)
                myname++;
        else
                myname = argv[0];
        (void) snprintf(typename, sizeof (typename), "%s %s", fstype, myname);
        argv[0] = typename;

        opts[0] = '\0';

        /*
         * Set options
         */
        while ((c = getopt(argc, argv, "gmo:pqrVO")) != EOF) {
                switch (c) {

                case 'g':
                        gflg++;
                        break;

                case 'o':
                        if (strlcpy(opts, optarg, sizeof (opts)) >=
                            sizeof (opts)) {
                                (void) fprintf(stderr, gettext("option string "
                                    "argument too long\n"));
                        }
                        break;

                case 'O':
                        Oflg++;
                        break;

                case 'r':
                        ro++;
                        break;

                case 'm':
                        mflg++;
                        break;

                case 'q':
                        qflg++;
                        break;

                default:
                        usage();
                }
        }

        if ((argc - optind) != 2)
                usage();

        mnt.mnt_special = argv[optind];
        mnt.mnt_mountp = argv[optind+1];
        mnt.mnt_fstype = fstype;

        /*
         * Process options.  The resulting options string overwrites the
         * original.
         *
         * XXX: This code doesn't do a good job of resolving options that are
         *      specified multiple times or that are given in conflicting
         *      forms (e.g., both "largefiles" and "nolargefiles").  It also
         *      doesn't produce well defined behavior for options that may
         *      also be specified as flags (e.g, "-r" and "ro"/"rw") when both
         *      are present.
         *
         *      The proper way to deal with such conflicts is to start with
         *      the default value (i.e., the one if no flag or option is
         *      specified), override it with the last mentioned option pair
         *      in the -o option string, and finally, override that with
         *      the flag value. This allows "mount -r" command to mount a
         *      file system read only that is listed rw in /etc/vfstab.
         */
        mnt.mnt_mntopts = opts;
        if (findopt(mnt.mnt_mntopts, "m"))
                mflg++;
        if ((gflg || findopt(mnt.mnt_mntopts, MNTOPT_GLOBAL)) &&
            findopt(mnt.mnt_mntopts, MNTOPT_NBMAND)) {
                (void) fprintf(stderr, gettext("NBMAND option not supported on"
                " global filesystem\n"));
                exit(32);
        }

        replace_opts(opts, ro, MNTOPT_RO, MNTOPT_RW);
        replace_opts(opts, largefiles, MNTOPT_NOLARGEFILES, MNTOPT_LARGEFILES);
        gflg = replace_opts_dflt(opts, gflg, MNTOPT_GLOBAL, MNTOPT_NOGLOBAL);

        if (findopt(mnt.mnt_mntopts, MNTOPT_RQ)) {
                rmopt(&mnt, MNTOPT_RQ);
                replace_opts(opts, 1, MNTOPT_QUOTA, MNTOPT_NOQUOTA);
        }

        mountfs(&mnt);
        return (0);
}

static void
reportlogerror(int ret, char *mp, char *special, char *cmd, fiolog_t *flp)
{
        /* No error */
        if ((ret != -1) && (flp->error == FIOLOG_ENONE))
                return;

        /* logging was not enabled/disabled */
        if (ret == -1 || flp->error != FIOLOG_ENONE)
                (void) fprintf(stderr, gettext("Could not %s logging"
                " for %s on %s.\n"), cmd, mp, special);

        /* ioctl returned error */
        if (ret == -1)
                return;

        /* Some more info */
        switch (flp->error) {
        case FIOLOG_ENONE :
                if (flp->nbytes_requested &&
                    (flp->nbytes_requested != flp->nbytes_actual)) {
                        (void) fprintf(stderr, gettext("The log has been"
                        " resized from %d bytes to %d bytes.\n"),
                            flp->nbytes_requested,
                            flp->nbytes_actual);
                }
                return;
        case FIOLOG_ETRANS :
                (void) fprintf(stderr, gettext("Solaris Volume Manager logging"
                " is already enabled.\n"));
                (void) fprintf(stderr, gettext("Please see the"
                " commands metadetach(1M)"
                " or metaclear(1M).\n"));
                break;
        case FIOLOG_EROFS :
                (void) fprintf(stderr, gettext("File system is mounted read "
                "only.\n"));
                (void) fprintf(stderr, gettext("Please see the remount "
                "option described in mount_ufs(1M).\n"));
                break;
        case FIOLOG_EULOCK :
                (void) fprintf(stderr, gettext("File system is locked.\n"));
                (void) fprintf(stderr, gettext("Please see the -u option "
                "described in lockfs(1M).\n"));
                break;
        case FIOLOG_EWLOCK :
                (void) fprintf(stderr, gettext("The file system could not be"
                " write locked.\n"));
                (void) fprintf(stderr, gettext("Please see the -w option "
                "described in lockfs(1M).\n"));
                break;
        case FIOLOG_ECLEAN :
                (void) fprintf(stderr, gettext("The file system may not be"
                " stable.\n"));
                (void) fprintf(stderr, gettext("Please see the -n option"
                " for fsck(1M).\n"));
                break;
        case FIOLOG_ENOULOCK :
                (void) fprintf(stderr, gettext("The file system could not be"
                " unlocked.\n"));
                (void) fprintf(stderr, gettext("Please see the -u option "
                "described in lockfs(1M).\n"));
                break;
        default :
                (void) fprintf(stderr, gettext("Unknown internal error"
                " %d.\n"), flp->error);
                break;
        }
}

static int
checkislog(char *mp)
{
        int fd;
        uint32_t islog;

        fd = open(mp, O_RDONLY);
        islog = 0;
        (void) ioctl(fd, _FIOISLOG, &islog);
        (void) close(fd);
        return ((int)islog);
}

static void
enable_logging(char *mp, char *special)
{
        int fd, ret, islog;
        fiolog_t fl;

        fd = open(mp, O_RDONLY);
        if (fd == -1) {
                perror(mp);
                return;
        }
        fl.nbytes_requested = 0;
        fl.nbytes_actual = 0;
        fl.error = FIOLOG_ENONE;
        ret = ioctl(fd, _FIOLOGENABLE, &fl);
        if (ret == -1)
                perror(mp);
        (void) close(fd);

        /* is logging enabled? */
        islog = checkislog(mp);

        /* report errors, if any */
        if (ret == -1 || !islog)
                reportlogerror(ret, mp, special, "enable", &fl);
}

static void
disable_logging(char *mp, char *special)
{
        int fd, ret, islog;
        fiolog_t fl;

        fd = open(mp, O_RDONLY);
        if (fd == -1) {
                perror(mp);
                return;
        }
        fl.error = FIOLOG_ENONE;
        ret = ioctl(fd, _FIOLOGDISABLE, &fl);
        if (ret == -1)
                perror(mp);
        (void) close(fd);

        /* is logging enabled? */
        islog = checkislog(mp);

        /* report errors, if any */
        if (ret == -1 || islog)
                reportlogerror(ret, mp, special, "disable", &fl);
}


/*
 * attempt to mount file system, return errno or 0
 */
void
mountfs(struct mnttab *mnt)
{
        char                     opt[MAX_MNTOPT_STR];
        char                     opt2[MAX_MNTOPT_STR];
        char                    *opts = opt;
        int                      flags = MS_OPTIONSTR;
        struct ufs_args          args;
        int                      need_separator = 0;
        int                     mount_attempts = 5;

        (void) bzero((char *)&args, sizeof (args));
        (void) strcpy(opts, mnt->mnt_mntopts);
        opt2[0] = '\0';

        flags |= Oflg ? MS_OVERLAY : 0;
        flags |= eatmntopt(mnt, MNTOPT_RO) ? MS_RDONLY : 0;
        flags |= eatmntopt(mnt, MNTOPT_REMOUNT) ? MS_REMOUNT : 0;
        flags |= eatmntopt(mnt, MNTOPT_GLOBAL) ? MS_GLOBAL : 0;

        if (eatmntopt(mnt, MNTOPT_NOINTR))
                args.flags |= UFSMNT_NOINTR;
        if (eatmntopt(mnt, MNTOPT_INTR))
                args.flags &= ~UFSMNT_NOINTR;
        if (eatmntopt(mnt, MNTOPT_SYNCDIR))
                args.flags |= UFSMNT_SYNCDIR;
        if (eatmntopt(mnt, MNTOPT_FORCEDIRECTIO)) {
                args.flags |= UFSMNT_FORCEDIRECTIO;
                args.flags &= ~UFSMNT_NOFORCEDIRECTIO;
        }
        if (eatmntopt(mnt, MNTOPT_NOFORCEDIRECTIO)) {
                args.flags |= UFSMNT_NOFORCEDIRECTIO;
                args.flags &= ~UFSMNT_FORCEDIRECTIO;
        }
        if (eatmntopt(mnt, MNTOPT_NOSETSEC))
                args.flags |= UFSMNT_NOSETSEC;
        if (eatmntopt(mnt, MNTOPT_LARGEFILES))
                args.flags |= UFSMNT_LARGEFILES;
        if (eatmntopt(mnt, MNTOPT_NOLARGEFILES))
                args.flags &= ~UFSMNT_LARGEFILES;
        args.flags |= UFSMNT_LOGGING;   /* default is logging */
        (void) eatmntopt(mnt, MNTOPT_LOGGING);
        if (eatmntopt(mnt, MNTOPT_NOLOGGING))
                args.flags &= ~UFSMNT_LOGGING;
        if (eatmntopt(mnt, MNTOPT_NOATIME))
                args.flags |= UFSMNT_NOATIME;
        if (eatmntopt(mnt, MNTOPT_DFRATIME))
                args.flags &= ~UFSMNT_NODFRATIME;
        if (eatmntopt(mnt, MNTOPT_NODFRATIME))
                args.flags |= UFSMNT_NODFRATIME;

        while (*opts != '\0') {
                char    *argval;

                switch (getsubopt(&opts, fop_subopts, &argval)) {
                case ONERROR:
                        if (argval) {
                                struct fop_subopt       *s;
                                int                      found = 0;

                                for (s = fop_subopt_list;
                                    s->str && !found;
                                    s++) {
                                        if (strcmp(argval, s->str) == 0) {
                                                args.flags |= s->flag;
                                                found = 1;
                                        }
                                }
                                if (!found) {
                                        usage();
                                }

                                if (need_separator)
                                        (void) strcat(opt2, ",");
                                (void) strcat(opt2, MNTOPT_ONERROR);
                                (void) strcat(opt2, "=");
                                (void) strcat(opt2, argval);
                                need_separator = 1;

                        } else {
                                args.flags |= UFSMNT_ONERROR_DEFAULT;
                        }
                        break;

                case NOMATCH:
                default:
                        if (argval) {
                                if (need_separator)
                                        (void) strcat(opt2, ",");
                                (void) strcat(opt2, argval);
                                need_separator = 1;
                        }
                        break;

                }
        }

        if (*opt2 != '\0')
                (void) strcpy(opt, opt2);
        opts = opt;
        if ((args.flags & UFSMNT_ONERROR_FLGMASK) == 0)
                args.flags |= UFSMNT_ONERROR_DEFAULT;

        (void) signal(SIGHUP,  SIG_IGN);
        (void) signal(SIGQUIT, SIG_IGN);
        (void) signal(SIGINT,  SIG_IGN);

        errno = 0;
        flags |= MS_DATA | MS_OPTIONSTR;
        if (mflg)
                flags |= MS_NOMNTTAB;
        if (flags & MS_REMOUNT) {
                replace_opts(mnt->mnt_mntopts, 1, MNTOPT_RW, MNTOPT_RO);
        }
        fixopts(mnt, opts);

        /*
         * For global filesystems we want to pass in logging option
         * so that it shows up in the mnttab of all nodes. We add
         * logging option if its not specified.
         */
        if (gflg || findopt(mnt->mnt_mntopts, MNTOPT_GLOBAL)) {
                if (!(flags & MS_RDONLY)) {
                        if (mnt->mnt_mntopts != '\0')
                                (void) strcat(mnt->mnt_mntopts, ",");
                        (void) strcat(mnt->mnt_mntopts, MNTOPT_LOGGING);
                        args.flags |= UFSMNT_LOGGING;
                } else {
                        /*
                         * Turn off logging for read only global mounts.
                         * It was set to logging as default above.
                         */
                        if (mnt->mnt_mntopts != '\0')
                                (void) strcat(mnt->mnt_mntopts, ",");
                        (void) strcat(mnt->mnt_mntopts, MNTOPT_NOLOGGING);
                        args.flags &= ~UFSMNT_LOGGING;
                }
        }

again:  if (mount(mnt->mnt_special, mnt->mnt_mountp, flags, fstype,
            &args, sizeof (args), mnt->mnt_mntopts, MAX_MNTOPT_STR) != 0) {
                if (errno == EBUSY && !(flags & MS_OVERLAY)) {
                        /*
                         * Because of bug 6176743, any attempt to mount any
                         * filesystem could fail for reasons described in that
                         * bug.  We're trying to detect that situation here by
                         * checking that the filesystem we're mounting is not
                         * in /etc/mnttab yet.  When that bug is fixed, this
                         * code can be removed.
                         */
                        if (!in_mnttab(mnt->mnt_mountp) &&
                            mount_attempts-- > 0) {
                                (void) poll(NULL, 0, 50);
                                goto again;
                        }
                }
                rpterr(mnt->mnt_special, mnt->mnt_mountp);
                exit(32);
        }

        if (!(flags & MS_RDONLY)) {
                if (args.flags & UFSMNT_LOGGING)
                        enable_logging(mnt->mnt_mountp, mnt->mnt_special);
                else
                        disable_logging(mnt->mnt_mountp, mnt->mnt_special);
        }

        if (!qflg) {
                cmp_requested_to_actual_options(opts, mnt->mnt_mntopts,
                    mnt->mnt_special, mnt->mnt_mountp);
        }

        if (checkislog(mnt->mnt_mountp)) {
                /* update mnttab file if necessary */
                if (!mflg) {
                        struct stat64 statb;
                        struct mnttagdesc mtdesc;
                        int fd;

                        if (stat64(mnt->mnt_mountp, &statb) != 0)
                                exit(32);
                        /* do tag ioctl */
                        mtdesc.mtd_major = major(statb.st_dev);
                        mtdesc.mtd_minor = minor(statb.st_dev);
                        mtdesc.mtd_mntpt = mnt->mnt_mountp;
                        mtdesc.mtd_tag = MNTOPT_LOGGING;
                        if ((fd = open(MNTTAB, O_RDONLY, 0)) < 0)
                                exit(32);
                        if (ioctl(fd, MNTIOC_SETTAG, &mtdesc) != 0) {
                                (void) close(fd);
                                exit(32);
                        }
                        (void) close(fd);
                }
        }
        exit(0);
}

/*
 * same as findopt but remove the option from the option string and return
 * true or false
 */
static int
eatmntopt(struct mnttab *mnt, char *opt)
{
        int has;

        has = (findopt(mnt->mnt_mntopts, opt) != NULL);
        rmopt(mnt, opt);
        return (has);
}

/*
 * remove an option string from the option list
 */
static void
rmopt(struct mnttab *mnt, char *opt)
{
        char *str;
        char *optstart;

        while (optstart = findopt(mnt->mnt_mntopts, opt)) {
                for (str = optstart;
                    *str != ',' && *str != '\0' && *str != ' ';
                    str++)
                        /* NULL */;
                if (*str == ',') {
                        str++;
                } else if (optstart != mnt->mnt_mntopts) {
                        optstart--;
                }
                while (*optstart++ = *str++)
                        ;
        }
}

/*
 * mnt->mnt_ops has un-eaten opts, opts is the original opts list.
 * Set mnt->mnt_opts to the original, the kernel will then remove
 * the ones it cannot deal with.
 * Set "opts" to the the original options for later comparison in
 * cmp_....().  But strip the options which aren't returned by
 * the kernel: "noglobal", "global" and "quota".
 * And strip the options which aren't set through mount: "logging",
 * "nologging" from those passed to mount(2).
 */
static void
fixopts(struct mnttab *mnt, char *opts)
{
        struct mnttab omnt;

        omnt.mnt_mntopts = opts;

        /*
         * Options not passed to the kernel and possibly not returned;
         * these are dealt with using ioctl; and the ioctl may fail.
         */
        rmopt(&omnt, MNTOPT_LOGGING);
        rmopt(&omnt, MNTOPT_NOLOGGING);

        /*
         * Set the options for ``/etc/mnttab'' to be the original
         * options from main(); except for the option "f" and "remount".
         */
        (void) strlcpy(mnt->mnt_mntopts, opts, MAX_MNTOPT_STR);
        rmopt(mnt, "f");
        rmopt(mnt, MNTOPT_REMOUNT);

        rmopt(&omnt, MNTOPT_GLOBAL);
        rmopt(&omnt, MNTOPT_NOGLOBAL);
        rmopt(&omnt, MNTOPT_QUOTA);
}

static void
usage(void)
{
        (void) fprintf(stdout, gettext(
"ufs usage:\n"
"mount [-F ufs] [generic options] [-o suboptions] {special | mount_point}\n"));
        (void) fprintf(stdout, gettext(
        "\tsuboptions are: \n"
        "\t     ro,rw,nosuid,remount,f,m,\n"
        "\t     global,noglobal,\n"
        "\t     largefiles,nolargefiles,\n"
        "\t     forcedirectio,noforcedirectio\n"
        "\t     logging,nologging,\n"
        "\t     nbmand,nonbmand,\n"
        "\t     onerror[={panic | lock | umount}]\n"));

        exit(32);
}

/*
 * Returns the next option in the option string.
 */
static char *
getnextopt(char **p)
{
        char *cp = *p;
        char *retstr;

        while (*cp && isspace(*cp))
                cp++;
        retstr = cp;
        while (*cp && *cp != ',')
                cp++;
        /* strip empty options */
        while (*cp == ',') {
                *cp = '\0';
                cp++;
        }
        *p = cp;
        return (retstr);
}

/*
 * "trueopt" and "falseopt" are two settings of a Boolean option.
 * If "flag" is true, forcibly set the option to the "true" setting; otherwise,
 * if the option isn't present, set it to the false setting.
 */
static void
replace_opts(char *options, int flag, char *trueopt, char *falseopt)
{
        char *f;
        char *tmpoptsp;
        int found;
        char tmptopts[MNTMAXSTR];

        (void) strcpy(tmptopts, options);
        tmpoptsp = tmptopts;
        (void) strcpy(options, "");

        found = 0;
        for (f = getnextopt(&tmpoptsp); *f; f = getnextopt(&tmpoptsp)) {
                if (options[0] != '\0')
                        (void) strcat(options, ",");
                if (strcmp(f, trueopt) == 0) {
                        (void) strcat(options, f);
                        found++;
                } else if (strcmp(f, falseopt) == 0) {
                        if (flag)
                                (void) strcat(options, trueopt);
                        else
                                (void) strcat(options, f);
                        found++;
                } else
                        (void) strcat(options, f);
        }
        if (!found) {
                if (options[0] != '\0')
                        (void) strcat(options, ",");
                (void) strcat(options, flag ? trueopt : falseopt);
        }
}

/*
 * "trueopt" and "falseopt" are two settings of a Boolean option and "dflt" is
 * a default value for the option.  Rewrite the contents of options to include
 * only the last mentioned occurrence of trueopt and falseopt.  If neither is
 * mentioned, append one or the other to options, according to the value of
 * dflt.  Return the resulting value of the option in boolean form.
 *
 * Note that the routine is implemented to have the resulting occurrence of
 * trueopt or falseopt appear at the end of the resulting option string.
 *
 * N.B. This routine should take the place of replace_opts, but there are
 *      probably some compatibility issues to resolve before doing so.  It
 *      should certainly be used to handle new options that don't have
 *      compatibility issues.
 */
static int
replace_opts_dflt(
        char *options,
        int dflt,
        const char *trueopt,
        const char *falseopt)
{
        char *f;
        char *tmpoptsp;
        int last;
        char tmptopts[MNTMAXSTR];

        /*
         * Transfer the contents of options to tmptopts, in anticipation of
         * copying a subset of the contents back to options.
         */
        (void) strcpy(tmptopts, options);
        tmpoptsp = tmptopts;
        (void) strcpy(options, "");

        /*
         * Loop over each option value, copying non-matching values back into
         * options and updating the last seen occurrence of trueopt or
         * falseopt.
         */
        last = dflt;
        for (f = getnextopt(&tmpoptsp); *f; f = getnextopt(&tmpoptsp)) {
                /* Check for both forms of the option of interest. */
                if (strcmp(f, trueopt) == 0) {
                        last = 1;
                } else if (strcmp(f, falseopt) == 0) {
                        last = 0;
                } else {
                        /* Not what we're looking for; transcribe. */
                        if (options[0] != '\0')
                                (void) strcat(options, ",");
                        (void) strcat(options, f);
                }
        }

        /*
         * Transcribe the correct form of the option of interest, using the
         * default value if it wasn't overwritten above.
         */
        if (options[0] != '\0')
                (void) strcat(options, ",");
        (void) strcat(options, last ? trueopt : falseopt);

        return (last);
}

static void
rpterr(char *bs, char *mp)
{
        switch (errno) {
        case EPERM:
                (void) fprintf(stderr, gettext("%s: Insufficient privileges\n"),
                    myname);
                break;
        case ENXIO:
                (void) fprintf(stderr, gettext("%s: %s no such device\n"),
                    myname, bs);
                break;
        case ENOTDIR:
                (void) fprintf(stderr,
                    gettext(
        "%s: %s not a directory\n\tor a component of %s is not a directory\n"),
                    myname, mp, bs);
                break;
        case ENOENT:
                (void) fprintf(stderr, gettext(
                    "%s: %s or %s, no such file or directory\n"),
                    myname, bs, mp);
                break;
        case EINVAL:
                (void) fprintf(stderr, gettext("%s: %s is not this fstype\n"),
                    myname, bs);
                break;
        case EBUSY:
                (void) fprintf(stderr,
                    gettext("%s: %s is already mounted or %s is busy\n"),
                    myname, bs, mp);
                break;
        case ENOTBLK:
                (void) fprintf(stderr, gettext(
                    "%s: %s not a block device\n"), myname, bs);
                break;
        case EROFS:
                (void) fprintf(stderr, gettext("%s: %s write-protected\n"),
                    myname, bs);
                break;
        case ENOSPC:
                (void) fprintf(stderr, gettext(
                    "%s: The state of %s is not okay\n"
                    "\tand it was attempted to be mounted read/write\n"),
                    myname, bs);
                (void) printf(gettext(
                    "mount: Please run fsck and try again\n"));
                break;
        case EFBIG:
                (void) fprintf(stderr, gettext(
                    "%s: Large files may be present on %s,\n"
                    "\tand it was attempted to be mounted nolargefiles\n"),
                    myname, bs);
                break;
        default:
                perror(myname);
                (void) fprintf(stderr, gettext("%s: Cannot mount %s\n"),
                    myname, bs);
        }
}